@nlabs/reaktor 0.8.1 → 0.10.0

package/lib/actions/users.js

@@ -33,17 +33,21 @@ __export(users_exports, {
   createToken: () => createToken,
   deactivateUser: () => deactivateUser,
   deleteUser: () => deleteUser,
+  forgotPassword: () => forgotPassword,
   getActiveUserCount: () => getActiveUserCount,
   getDisplayName: () => getDisplayName,
   getSessionUser: () => getSessionUser,
   getUser: () => getUser,
+  getUserByToken: () => getUserByToken,
   getUserOptional: () => getUserOptional,
   getUsers: () => getUsers,
+  getUsersByConnection: () => getUsersByConnection,
   getUsersByLatest: () => getUsersByLatest,
   getUsersByReactions: () => getUsersByReactions,
   getUsersByTags: () => getUsersByTags,
   parseUserOptions: () => parseUserOptions,
   refreshSession: () => refreshSession,
+  resetPassword: () => resetPassword,
   signIn: () => signIn,
   signOut: () => signOut,
   updateUser: () => updateUser
@@ -52,12 +56,17 @@ module.exports = __toCommonJS(users_exports);
 var import_utils = require("@nlabs/utils");
 var import_arangojs = require("arangojs");
 var import_luxon = require("luxon");
-var import_stripe = __toESM(require("stripe"));
+var import_stripe = __toESM(require("stripe"), 1);
+var import_userAdapter = require("../adapters/userAdapter");
 var import_config = require("../config");
-var import_utils2 = require("../utils");
+var import_email = require("./email");
+var import_sms = require("./sms");
+var import_error = require("../types/error.types");
+var import_analyticsUtils = require("../utils/analyticsUtils");
+var import_arangodbUtils = require("../utils/arangodbUtils");
 var import_session = require("../utils/session");
 const eventCategory = "users";
-const apiVersion = "2020-03-02";
+const STRIPE_API_VERSION = "2025-05-28.basil";
 var UserAccess = /* @__PURE__ */ ((UserAccess2) => {
   UserAccess2[UserAccess2["DEACTIVATED"] = 0] = "DEACTIVATED";
   UserAccess2[UserAccess2["ACTIVE"] = 1] = "ACTIVE";
@@ -66,27 +75,29 @@ var UserAccess = /* @__PURE__ */ ((UserAccess2) => {
   UserAccess2[UserAccess2["ADMIN"] = 4] = "ADMIN";
   return UserAccess2;
 })(UserAccess || {});
-const createToken = (userId, username, userAccess, expires = 15) => {
+const createToken = (userId, username, userAccess, expiresInMinutes = 15) => {
   const now = import_luxon.DateTime.local();
-  const sessionExpires = now.plus({ minutes: expires });
+  const sessionExpires = now.plus({ minutes: expiresInMinutes });
   const iat = Math.floor(now.toSeconds());
   const exp = Math.floor(sessionExpires.toSeconds());
   const token = (0, import_session.setSession)({
     exp,
     iat,
-    username,
     userAccess,
-    userId
+    userId,
+    username
   });
   return {
     expires: sessionExpires.toMillis(),
     issued: now.toMillis(),
-    token
+    token,
+    userId,
+    username
   };
 };
 const getUserOptional = (fields = []) => fields.reduce((selects, field) => {
   if (field.includes("Count")) {
-    return (0, import_utils2.selectReactionCountByType)("users", "u", field, selects);
+    return (0, import_arangodbUtils.selectReactionCountByType)("users", "u", field, selects);
   }
   return selects;
 }, { objects: [], queries: [] });
@@ -95,30 +106,37 @@ const parseUserOptions = (options = {}) => {
     from = 0,
     to = 30
   } = options;
+  const limit = (0, import_arangodbUtils.getLimit)(from, to);
   return {
     ...options,
-    limit: (0, import_utils2.getLimit)(from, to)
+    limit
   };
 };
-const addUser = async (context, args) => {
+const addUser = async (context, user) => {
   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 { email, password, phone, username } = (0, import_userAdapter.parseUser)(user);
   const formatUsername = (0, import_utils.parseUsername)(username);
   const formatEmail = (0, import_utils.parseEmail)(email);
   const formatPhone = (0, import_utils.parsePhone)(phone);
-  if (!formatUsername || !password || !formatPhone && !formatEmail) {
-    return (0, import_utils2.logException)({
+  const formatPassword = (0, import_utils.parsePassword)(password);
+  const hasPassword = !!formatPassword;
+  const hasUsername = !!formatUsername || !!formatPhone || !!formatEmail;
+  if (!hasPassword || !hasUsername) {
+    return (0, import_analyticsUtils.logException)({
       action,
-      args: { username },
       category: eventCategory,
-      value: import_utils2.ErrorTypes.INVALID_ARGUMENTS
+      params: { username },
+      value: import_error.ErrorTypes.INVALID_ARGUMENTS
     }, context);
   }
-  const filters = [`u.username == "${formatUsername}"`];
+  const hashId = formatUsername || formatPhone || formatEmail;
+  const salt = (0, import_utils.createHash)(`${hashId}${formatPassword}`, null);
+  const encryptedPassword = (0, import_utils.createPassword)(formatPassword, salt);
+  const filters = [];
+  if (formatUsername) {
+    filters.push(`u.username == "${formatUsername}"`);
+  }
   if (formatEmail) {
     filters.push(`u.email == "${formatEmail}"`);
   }
@@ -127,101 +145,222 @@ const addUser = async (context, args) => {
   }
   const checkQuery = `FOR u IN users
     FILTER ${filters.join(" || ")}
+    LIMIT 1
     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)({
+  try {
+    const existingUsers = await database.query(checkQuery).then((cursor) => cursor.all());
+    if (existingUsers.length) {
+      return (0, import_analyticsUtils.logException)({
+        action,
+        category: eventCategory,
+        params: {
+          email: formatEmail,
+          phone: formatPhone,
+          username: formatUsername
+        },
+        value: import_error.ErrorTypes.EXISTING_ITEM
+      }, context);
+    }
+  } catch (error) {
+    return (0, import_analyticsUtils.logError)({
       action,
-      args: { username },
       category: eventCategory,
-      value: import_utils2.ErrorTypes.EXISTING_USERNAME
-    }, context);
+      params: { username },
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, 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),
+    _key: (0, import_utils.createHash)(formatUsername, null),
     added: Date.now(),
     email: formatEmail,
     modified: Date.now(),
     password: encryptedPassword,
     phone: formatPhone,
     salt,
-    username: formatUsername,
     userAccess: 1,
+    username: formatUsername,
     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)
-  );
+  return await database.query(insertQuery).then((cursor) => cursor.next()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    params: { username },
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, context));
 };
 const updateUser = async (context, user) => {
   const action = "updateUser";
-  const { database } = context;
-  const { _key, _id, id, tags = [], userId, ...updated } = user;
-  let userDocId;
-  if (_id || id) {
-    userDocId = _id || id;
-  } else if (_key || userId) {
-    userDocId = `users/${_key || userId}`;
+  const { database, session } = context;
+  const { _key, _id, id, tags = [], userId, ...updated } = (0, import_userAdapter.parseUser)(user);
+  if (!(0, import_session.isAdminUser)(session) && session?.userId !== userId) {
+    return (0, import_analyticsUtils.logException)({
+      action,
+      category: eventCategory,
+      params: { session },
+      value: import_error.ErrorTypes.INVALID_SESSION
+    }, context);
   }
-  const userQuery = import_arangojs.aql`LET u = DOCUMENT(${userDocId})
+  const userQuery = import_arangojs.aql`LET u = DOCUMENT(${id})
     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;
+  try {
+    const updatedUser = await database.query(userQuery).then((cursor) => cursor.next());
+    const tagCollection = database.collection("isTagged");
+    await Promise.all(tags.map(({ id: tagDocId, name }) => {
+      const tagQuery = import_arangojs.aql`FOR it IN isTagged
+        FILTER it._from == ${tagDocId} && it._to == ${id} && it.name == ${name}
+        LIMIT 1
+        RETURN it`;
+      return database.query(tagQuery).then((cursor) => cursor.next()).then((tagEdge) => {
+        if (!!tagEdge) {
+          return tagEdge;
+        }
+        const edge = {
+          _from: tagDocId,
+          _key: (0, import_utils.createHash)(`isTagged-${tagDocId}-${id}`),
+          _to: id,
+          added: Date.now(),
+          name
+        };
+        return tagCollection.save(edge, { returnNew: true }).then(() => edge);
+      });
+    }));
+    return updatedUser;
+  } catch (error) {
+    return (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      params: { user },
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+  }
+};
+const forgotPassword = async (context, { email, phone, username }) => {
+  const action = "forgotPassword";
+  const { app, database } = context;
+  const aqlQuery = import_arangojs.aql`FOR u IN users
+    FILTER u.email == ${email} || u.phone == ${phone} || u.username == ${username}
+    LIMIT 1
+    RETURN u`;
+  try {
+    return await database.query(aqlQuery).then(async (cursor) => {
+      const user = cursor.next();
+      if (user) {
+        const { email: email2, phone: phone2, verifiedEmail, verifiedPhone } = user;
+        const codeExpires = 1e3 * 60 * 15;
+        const code = Math.floor(1e5 + Math.random() * 9e5);
+        const userDocId = (0, import_arangodbUtils.getDocId)("users", user);
+        let update;
+        if (email2 && verifiedEmail) {
+          (0, import_email.sendEmail)({
+            app,
+            text: `Your code is ${code}`
+          });
+          update = { verifiedEmailCode: code, verifiedEmailExpires: codeExpires };
+        }
+        if (phone2 && verifiedPhone) {
+          (0, import_sms.sendSms)({
+            app,
+            text: `Your code is ${code}`
+          });
+          update = { verifiedPhoneCode: code, verifiedPhoneExpires: codeExpires };
+        }
+        if (update.verifiedEmailCode || update.verifiedPhoneCode) {
+          const updateQuery = import_arangojs.aql`UPDATE ${userDocId} WITH ${update} IN users`;
+          await database.query(updateQuery);
+          return true;
+        }
+        return false;
+      }
+      return false;
+    });
+  } catch (error) {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      params: { email, phone, username },
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+    return false;
+  }
+};
+const resetPassword = async (context, {
+  code,
+  password,
+  type,
+  username
+}) => {
+  const action = "resetPassword";
+  const { database } = context;
+  const formatPassword = (0, import_utils.parsePassword)(password);
+  const aqlQuery = import_arangojs.aql`FOR u IN users
+    FILTER u.username == ${username}
+    LIMIT 1
+    RETURN u`;
+  try {
+    return await database.query(aqlQuery).then(async (cursor) => {
+      const user = cursor.next();
+      if (user) {
+        const {
+          _id: userDocId,
+          salt,
+          verifiedEmailCode,
+          verifiedEmailExpires,
+          verifiedPhoneCode,
+          verifiedPhoneExpires
+        } = user;
+        const now = Date.now();
+        let update;
+        switch (type) {
+          case "email":
+            if (code === verifiedEmailCode && verifiedEmailExpires > now) {
+              const password2 = (0, import_utils.createPassword)(formatPassword, salt);
+              update = { password: password2 };
+            }
+            break;
+          case "phone":
+            if (code === verifiedPhoneCode && verifiedPhoneExpires > now) {
+              const password2 = (0, import_utils.createPassword)(formatPassword, salt);
+              update = { password: password2 };
+            }
+            break;
+          default:
+            return false;
+        }
+        if (update) {
+          const updateQuery = import_arangojs.aql`UPDATE ${userDocId} WITH ${update} IN users`;
+          await database.query(updateQuery);
+          return true;
+        }
       }
-      return tagCollection.save(edge, { returnNew: true }).then(() => edge);
-    }).catch((error) => (0, import_utils2.logError)({
+      return false;
+    });
+  } catch (error) {
+    (0, import_analyticsUtils.logError)({
       action,
       category: eventCategory,
-      label: "db_error"
-    }, error, context).then(() => null));
-  }));
-  return updatedUser;
+      params: { username },
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+    return false;
+  }
 };
-const confirmCode = async (context, args) => {
-  const action = "confirmEmail";
+const confirmCode = async (context, {
+  code,
+  type
+}) => {
+  const action = "confirmCode";
   const { database, session: { userId: sessionId } } = context;
-  const { code, type } = args;
-  const userDocId = `users/${sessionId}`;
+  const userDocId = (0, import_arangodbUtils.getDocId)("users", { userId: sessionId });
   const aqlQuery = import_arangojs.aql`LET u = DOCUMENT(${userDocId}) RETURN u`;
   try {
-    return database.query(aqlQuery).then((cursor) => cursor.next() || {}).then(({ verifiedEmailCode, verifiedPhoneCode }) => {
+    return await database.query(aqlQuery).then((cursor) => cursor.next()).then(({ verifiedEmailCode, verifiedPhoneCode }) => {
       switch (type) {
         case "email":
           return code === verifiedEmailCode;
@@ -230,65 +369,50 @@ const confirmCode = async (context, args) => {
         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) {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      params: { code, type },
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
     return false;
   }
 };
-const deleteUser = (context, args) => {
+const deleteUser = (context, user) => {
   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 { database } = context;
+  const { userId } = (0, import_userAdapter.parseUser)(user);
   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 stripeClient = new import_stripe.default(import_config.Config.get("stripe.token"), { apiVersion: STRIPE_API_VERSION, typescript: true });
+  return database.query(aqlQuery).then((cursor) => cursor.next()).then((deletedUser) => stripeClient.customers.del(deletedUser?.stripeCustomerId).then(() => stripeClient.accounts.del(deletedUser?.stripeAccountId)).then(() => deletedUser)).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    params: { userId },
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, context));
 };
-const deactivateUser = (context, userId) => {
+const deactivateUser = (context, user) => {
   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 { database } = context;
+  const { userId } = (0, import_userAdapter.parseUser)(user);
   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;
-  });
+  return database.query(aqlQuery).then((cursor) => cursor.next()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    params: { userId },
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, context));
 };
-const getDisplayName = (user = {}) => {
+const getDisplayName = (user) => {
   const { first, last, name = "", username = "" } = user;
   const fullname = [first, last].join(" ").trim();
   if (name) {
@@ -302,35 +426,47 @@ const getDisplayName = (user = {}) => {
 };
 const getSessionUser = (context) => {
   const action = "getSessionUser";
+  console.log("getSessionUser", { action, context });
   const { database, fields, session: { userId: sessionId, username } } = context;
   const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
-  const aqlQuery = `LET u = DOCUMENT("users/${sessionId}")
+  const formatSessionId = (0, import_utils.parseArangoId)(`users/${sessionId}`);
+  const aqlQuery = `LET u = DOCUMENT("${formatSessionId}")
   ${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));
+  return database.query(aqlQuery).then((cursor) => cursor.next()).catch((error) => {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      params: { userId: sessionId, username },
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+    return null;
+  });
 };
-const getUser = (context, args) => {
+const getUser = (context, user) => {
   const action = "getUser";
-  const { userId } = args;
+  const { id, userId, username } = (0, import_userAdapter.parseUser)(user);
   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}")
+  let aqlQuery;
+  console.log({ id, userId, username });
+  if (id) {
+    aqlQuery = `LET u = DOCUMENT("${id}")
     ${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)({
+  } else if (username) {
+    aqlQuery = `FOR u IN users
+    FILTER u.username == "${username}"
+    ${selectQueries.join("\n")}
+    RETURN MERGE(u, {${selectObjects.join(", ")}})`;
+  }
+  return database.query(aqlQuery).then((cursor) => cursor.next()).then((user2) => user2).catch((error) => (0, import_analyticsUtils.logError)({
     action,
-    args,
     category: eventCategory,
-    label: import_utils2.ErrorTypes.DATABASE_ERROR
-  }, error, context).then(() => {
-  }));
+    params: { id, userId, username },
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, context));
 };
 const getUsers = (context, options) => {
   const action = "getUserList";
@@ -347,11 +483,14 @@ const getUsers = (context, options) => {
     ${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(() => []));
+  return database.query(aqlQuery).then((cursor) => cursor.all()).catch((error) => {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+    return [];
+  });
 };
 const getUsersByReactions = (context, { reactions = [], username }, options) => {
   const action = "getUsersByReactions";
@@ -361,27 +500,32 @@ const getUsersByReactions = (context, { reactions = [], username }, 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))`];
+  const filterBy = [
+    "u.userAccess > 0",
+    `POSITION(${JSON.stringify(formatReactions)}, LOWER(r.name))`
+  ];
   if (username) {
     filterBy.push(`CONTAINS(u.username, "${formatUsername}")`);
   }
   const aqlQuery = `FOR u, r IN OUTBOUND "${formatSessionId}" hasReaction
     OPTIONS {vertexCollections: "users"}
     ${selectQueries.join("\n")}
-    ${filterBy.length ? `FILTER ${filterBy.join(" && ")}` : ""}
+    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(() => []));
+  return database.query(aqlQuery).then((cursor) => cursor.all()).catch((error) => {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+    return [];
+  });
 };
 const getUsersByTags = (context, { tags, username }, options) => {
   const action = "getUsersByTags";
   const { database, fields, session: { userId: sessionId } } = context;
-  const formatTags = tags.reduce((list, tagName) => {
+  const formatTags = tags?.reduce((list, tagName) => {
     if (tagName) {
       list.push((0, import_utils.parseChar)(tagName, 32).toLowerCase());
     }
@@ -390,7 +534,10 @@ const getUsersByTags = (context, { tags, username }, options) => {
   const { limit } = parseUserOptions(options);
   const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
   const formatUsername = (0, import_utils.parseUsername)(username);
-  const filterBy = [`u._key != "${sessionId}"`];
+  const filterBy = [
+    `u._key != "${sessionId}"`,
+    "u.userAccess > 0"
+  ];
   if (username) {
     filterBy.push(`CONTAINS(u.username, "${formatUsername}")`);
   }
@@ -399,21 +546,26 @@ const getUsersByTags = (context, { tags, username }, options) => {
     FOR u, it IN OUTBOUND t isTagged
     OPTIONS {bfs: true, uniqueVertices: "global", vertexCollections: "users"}
     ${selectQueries.join("\n")}
-    ${filterBy.length ? `FILTER ${filterBy.join(" && ")}` : ""}
+    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(() => []));
+  return database.query(aqlQuery).then((cursor) => cursor.all()).catch((error) => {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+    return [];
+  });
 };
 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 filter = [
+    "u._id != session._id",
+    "u.userAccess > 0"
+  ];
   const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
   if (username) {
     filter.push(`CONTAINS(u.username, "${(0, import_utils.parseUsername)(username)}")`);
@@ -426,72 +578,131 @@ const getUsersByLatest = (context, { username }, options) => {
     ${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(() => []));
+  return database.query(aqlQuery).then((cursor) => cursor.all()).catch((error) => {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+    return [];
+  });
 };
-const refreshSession = async (context, { expires, token }) => {
-  const { error } = (0, import_session.getSession)(token);
-  if (error) {
-    return { errors: [error] };
+const getUsersByConnection = (context, { userId }, options) => {
+  const action = "getUsersByConnection";
+  const { database, fields } = context;
+  const { limit, username } = parseUserOptions(options);
+  const { objects: selectObjects, queries: selectQueries } = getUserOptional(fields);
+  const formatUserId = (0, import_utils.parseArangoId)(`users/${userId}`);
+  const filterBy = [
+    "u.userAccess > 0"
+  ];
+  if (username) {
+    filterBy.push(`CONTAINS(u.username, "${(0, import_utils.parseUsername)(username)}")`);
   }
-  const { exp, userId, username, userAccess } = (0, import_session.getSession)(token);
-  const now = Math.ceil(import_luxon.DateTime.local().toSeconds());
-  if (exp > now) {
+  const aqlQuery = `FOR cu IN users
+    LET session = DOCUMENT("${formatUserId}")
+    FOR u, connection IN OUTBOUND cu hasConnection
+    OPTIONS {bfs: true, uniqueVertices: "global", vertexCollections: "users"}
+    ${selectQueries.join("\n")}
+    FILTER ${filterBy.join(" && ")}
+    ${limit.aql}
+    RETURN DISTINCT MERGE(u, {${selectObjects.join(", ")}})`;
+  return database.query(aqlQuery).then((cursor) => cursor.all()).catch((error) => {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+    return [];
+  });
+};
+const refreshSession = ({ expires, token }) => {
+  try {
+    const { userId, username, userAccess } = (0, import_session.getSession)(token);
     return createToken(userId, username, userAccess, expires);
+  } catch (error) {
+    throw error;
   }
-  return { errors: ["session_expired"] };
 };
 const signIn = async (context, args) => {
   const action = "signIn";
-  const { expires, password, username } = args;
+  const { database } = context;
+  const { email, expires, password, phone, username } = args;
+  const formatEmail = (0, import_utils.parseEmail)(email);
   const formatUsername = (0, import_utils.parseUsername)(username);
   const formatPassword = (0, import_utils.parsePassword)(password);
+  const formatPhone = (0, import_utils.parsePhone)(phone);
   const formatExpires = (0, import_utils.parseNum)(expires) || 15;
-  const { database } = context;
-  if (!formatUsername || !formatPassword) {
-    return (0, import_utils2.logException)({
+  if (!formatUsername && !formatEmail && !formatPhone || !formatPassword) {
+    (0, import_analyticsUtils.logException)({
       action,
-      args: { username },
       category: eventCategory,
-      value: import_utils2.ErrorTypes.INVALID_ARGUMENTS
+      params: { username },
+      value: import_error.ErrorTypes.INVALID_ARGUMENTS
     }, context);
+    return null;
   }
-  const checkQuery = import_arangojs.aql`FOR u IN users
-    FILTER u.username == ${formatUsername}
+  const filters = [];
+  if (formatEmail) {
+    filters.push(`u.email == "${formatEmail}"`);
+  }
+  if (formatPhone) {
+    filters.push(`u.phone == ${formatPhone}`);
+  }
+  if (formatUsername) {
+    filters.push(`u.username == "${formatUsername}"`);
+  }
+  const checkQuery = `FOR u IN users
+    FILTER ${filters.join(" || ")}
     LIMIT 1
     RETURN u`;
-  const checkUser = await database.query(checkQuery).then((cursor) => cursor.next()).catch(
-    (error) => (0, import_utils2.logError)({
+  let checkUser;
+  try {
+    checkUser = await database.query(checkQuery).then((cursor) => cursor.next());
+  } catch (error) {
+    (0, import_analyticsUtils.logError)({
       action,
-      args: { username: formatUsername },
       category: eventCategory,
-      label: import_utils2.ErrorTypes.DATABASE_ERROR
-    }, error, context).then(() => null)
-  );
+      params: { username: formatUsername },
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+    return null;
+  }
   if (!checkUser) {
-    return (0, import_utils2.logException)({
+    (0, import_analyticsUtils.logException)({
       action,
-      args: { username },
       category: eventCategory,
-      value: import_utils2.ErrorTypes.INVALID_AUTHENTICATION
+      params: { username },
+      value: import_error.ErrorTypes.INVALID_AUTHENTICATION
     }, context);
+    return null;
   }
-  const { _key: userId, salt, userAccess } = checkUser;
+  const { _key: userId, password: validPassword, salt, userAccess } = checkUser;
   const authPassword = (0, import_utils.createPassword)(formatPassword, salt);
-  if (checkUser.password !== authPassword) {
-    return (0, import_utils2.logException)({
+  if (validPassword !== authPassword) {
+    (0, import_analyticsUtils.logException)({
       action,
-      args: { username },
       category: eventCategory,
-      value: import_utils2.ErrorTypes.INVALID_AUTHENTICATION
+      params: { userAccess, userId, username },
+      value: import_error.ErrorTypes.INVALID_AUTHENTICATION
     }, context);
+    return null;
+  }
+  try {
+    console.log({ formatExpires, userAccess, userId, username });
+    const token = createToken(userId, username, userAccess, formatExpires);
+    console.log({ token });
+    return token;
+  } catch (error) {
+    (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
+    return null;
   }
-  return createToken(userId, username, userAccess, formatExpires);
 };
-const signOut = async (context, args) => {
+const signOut = async (context) => {
   const action = "signOut";
   const { database, session: { userId: sessionId, username } } = context;
   const userDocId = `users/${sessionId}`;
@@ -504,16 +715,14 @@ const signOut = async (context, args) => {
     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)
-    );
+    await database.query(sessionQuery).then((cursor) => cursor.next());
   } catch (error) {
-    return false;
+    await (0, import_analyticsUtils.logError)({
+      action,
+      category: eventCategory,
+      params: { userId: sessionId, username },
+      value: import_error.ErrorTypes.DATABASE_ERROR
+    }, error, context);
   }
   return true;
 };
@@ -526,13 +735,24 @@ const getActiveUserCount = (context) => {
     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)
-  );
+  return database.query(countQuery).then((cursor) => cursor.next()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, context));
+};
+const getUserByToken = (context, token) => {
+  const action = "getUserByToken";
+  const { database } = context;
+  const { userId } = (0, import_session.getSession)(token);
+  const userDocId = (0, import_arangodbUtils.getDocId)("users", { userId });
+  const aqlQuery = import_arangojs.aql`LET u = DOCUMENT("${userDocId}") RETURN u`;
+  return database.query(aqlQuery).then((cursor) => cursor.next()).catch((error) => (0, import_analyticsUtils.logError)({
+    action,
+    category: eventCategory,
+    params: { userId },
+    value: import_error.ErrorTypes.DATABASE_ERROR
+  }, error, context));
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -542,19 +762,23 @@ const getActiveUserCount = (context) => {
   createToken,
   deactivateUser,
   deleteUser,
+  forgotPassword,
   getActiveUserCount,
   getDisplayName,
   getSessionUser,
   getUser,
+  getUserByToken,
   getUserOptional,
   getUsers,
+  getUsersByConnection,
   getUsersByLatest,
   getUsersByReactions,
   getUsersByTags,
   parseUserOptions,
   refreshSession,
+  resetPassword,
   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 {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(!formatUsername || !password || (!formatPhone && !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(formatEmail) {\n    filters.push(`u.email == \"${formatEmail}\"`);\n  }\n\n  if(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(name) {\n    return name;\n  } else if(fullname !== '') {\n    return fullname;\n  } else if(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(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(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}\" hasReaction\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(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(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(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(!formatUsername || !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": ["import_utils", "UserAccess", "Stripe"]
}

+//# 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  parseArangoId,\n  parseChar,\n  parseEmail,\n  parseNum,\n  parsePassword,\n  parsePhone,\n  parseUsername\n} from '@nlabs/utils';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {DateTime} from 'luxon';\nimport Stripe from 'stripe';\n\nimport {parseUser} from '../adapters/userAdapter';\nimport {Config} from '../config';\nimport {sendEmail} from './email';\nimport {sendSms} from './sms';\nimport {ErrorTypes, SessionError} from '../types/error.types';\nimport {logError, logException} from '../utils/analyticsUtils';\nimport {getDocId, getLimit, selectReactionCountByType} from '../utils/arangodbUtils';\nimport {getSession, isAdminUser, SessionToken, setSession} from '../utils/session';\n\nimport type {ApiContext} from '../types/auth.types';\nimport type {UserType} from '../types/users.types';\nimport type {EdgeCollection} from 'arangojs/collections';\n\n\nconst eventCategory = 'users';\nconst STRIPE_API_VERSION = '2025-05-28.basil';\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  expiresInMinutes: number = 15\n): SessionToken => {\n  const now: DateTime = DateTime.local();\n  const sessionExpires: DateTime = now.plus({minutes: expiresInMinutes});\n  const iat: number = Math.floor(now.toSeconds());\n  const exp: number = Math.floor(sessionExpires.toSeconds());\n  const token = setSession({\n    exp,\n    iat,\n    userAccess,\n    userId,\n    username\n  });\n\n  return {\n    expires: sessionExpires.toMillis(),\n    issued: now.toMillis(),\n    token,\n    userId,\n    username\n  };\n};\n\ninterface SelectAccumulator {\n  objects: string[];\n  queries: string[];\n}\n\nexport const getUserOptional = (fields: string[] = []): SelectAccumulator =>\n  fields.reduce((selects: SelectAccumulator, 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  const limit = getLimit(from, to);\n\n  return {\n    ...options,\n    limit\n  };\n};\n\nexport const addUser = async (context: ApiContext, user: UserType): Promise<UserType> => {\n  const action = 'addUser';\n  const {database} = context;\n  const {email, password, phone, username} = parseUser(user);\n  const formatUsername: string = parseUsername(username);\n  const formatEmail: string = parseEmail(email);\n  const formatPhone: string = parsePhone(phone);\n  const formatPassword: string = parsePassword(password);\n  const hasPassword = !!formatPassword;\n  const hasUsername = !!formatUsername || !!formatPhone || !!formatEmail;\n\n  if(!hasPassword || !hasUsername) {\n    return logException({\n      action,\n      category: eventCategory,\n      params: {username},\n      value: ErrorTypes.INVALID_ARGUMENTS\n    }, context);\n  }\n\n  const hashId = formatUsername || formatPhone || formatEmail;\n  const salt: string = createHash(`${hashId}${formatPassword}`, null);\n  const encryptedPassword = createPassword(formatPassword, salt);\n  const filters: string[] = [];\n\n  if(formatUsername) {\n    filters.push(`u.username == \"${formatUsername}\"`);\n  }\n\n  if(formatEmail) {\n    filters.push(`u.email == \"${formatEmail}\"`);\n  }\n\n  if(formatPhone) {\n    filters.push(`u.phone == ${formatPhone}`);\n  }\n\n  const checkQuery: string = `FOR u IN users\n    FILTER ${filters.join(' || ')}\n    LIMIT 1\n    RETURN u`;\n\n  try {\n    const existingUsers = await database.query(checkQuery).then((cursor) => cursor.all());\n\n    if(existingUsers.length) {\n      return logException({\n        action,\n        category: eventCategory,\n        params: {\n          email: formatEmail,\n          phone: formatPhone,\n          username: formatUsername\n        },\n        value: ErrorTypes.EXISTING_ITEM\n      }, context);\n    }\n  } catch(error) {\n    return logError({\n      action,\n      category: eventCategory,\n      params: {username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, 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  const insert: UserType = {\n    _key: createHash(formatUsername, null),\n    added: Date.now(),\n    email: formatEmail,\n    modified: Date.now(),\n    password: encryptedPassword,\n    phone: formatPhone,\n    salt,\n    userAccess: 1,\n    username: formatUsername,\n    verifiedEmail: false,\n    verifiedEmailCode,\n    verifiedPhone: false,\n    verifiedPhoneCode\n  };\n\n  const insertQuery: AqlQuery = aql`INSERT ${insert} IN users RETURN NEW`;\n\n  return await database.query(insertQuery)\n    .then((cursor) => cursor.next())\n    .catch((error) => logError({\n      action,\n      category: eventCategory,\n      params: {username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const updateUser = async (context: ApiContext, user: UserType): Promise<UserType> => {\n  const action = 'updateUser';\n  const {database, session} = context;\n  const {_key, _id, id, tags = [], userId, ...updated} = parseUser(user);\n\n  if(!isAdminUser(session) && (session?.userId !== userId)) {\n    return logException({\n      action,\n      category: eventCategory,\n      params: {session},\n      value: ErrorTypes.INVALID_SESSION\n    }, context);\n  }\n\n  const userQuery: AqlQuery = aql`LET u = DOCUMENT(${id})\n    UPDATE u WITH ${updated} IN users\n    RETURN NEW`;\n\n  try {\n    const updatedUser = await database.query(userQuery).then((cursor) => cursor.next());\n    const tagCollection: EdgeCollection = database.collection('isTagged');\n\n    await Promise.all(tags.map(({id: tagDocId, name}) => {\n      const tagQuery: AqlQuery = aql`FOR it IN isTagged\n        FILTER it._from == ${tagDocId} && it._to == ${id} && it.name == ${name}\n        LIMIT 1\n        RETURN it`;\n\n      return database.query(tagQuery)\n        .then((cursor) => cursor.next())\n        .then((tagEdge) => {\n          if(!!tagEdge) {\n            return tagEdge;\n          }\n\n          const edge = {\n            _from: tagDocId,\n            _key: createHash(`isTagged-${tagDocId}-${id}`),\n            _to: id,\n            added: Date.now(),\n            name\n          };\n\n          return tagCollection.save(edge, {returnNew: true}).then(() => edge);\n        });\n    }));\n\n    return updatedUser;\n  } catch(error) {\n    return logError({\n      action,\n      category: eventCategory,\n      params: {user},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n  }\n};\n\nexport const forgotPassword = async (context: ApiContext, {email, phone, username}): Promise<boolean> => {\n  const action = 'forgotPassword';\n  const {app, database} = context;\n  const aqlQuery: AqlQuery = aql`FOR u IN users\n    FILTER u.email == ${email} || u.phone == ${phone} || u.username == ${username}\n    LIMIT 1\n    RETURN u`;\n\n  try {\n    return await database.query(aqlQuery)\n      .then(async (cursor) => {\n        const user = cursor.next();\n\n        if(user) {\n          const {email, phone, verifiedEmail, verifiedPhone} = user as UserType;\n          const codeExpires = 1000 * 60 * 15; // 15 minutes\n          const code = Math.floor(100000 + (Math.random() * 900000));\n          const userDocId = getDocId('users', user);\n          let update;\n\n          if(email && verifiedEmail) {\n            sendEmail({\n              app,\n              text: `Your code is ${code}`\n            });\n            update = {verifiedEmailCode: code, verifiedEmailExpires: codeExpires};\n          }\n\n          if(phone && verifiedPhone) {\n            sendSms({\n              app,\n              text: `Your code is ${code}`\n            });\n            update = {verifiedPhoneCode: code, verifiedPhoneExpires: codeExpires};\n          }\n\n          if(update.verifiedEmailCode || update.verifiedPhoneCode) {\n            const updateQuery: AqlQuery = aql`UPDATE ${userDocId} WITH ${update} IN users`;\n\n            await database.query(updateQuery);\n\n            return true;\n          }\n\n          return false;\n        }\n\n        return false;\n      });\n  } catch(error) {\n    logError({\n      action,\n      category: eventCategory,\n      params: {email, phone, username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n\n    return false;\n  }\n};\n\nexport const resetPassword = async (\n  context: ApiContext,\n  {\n    code,\n    password,\n    type,\n    username\n  }: {\n    code: number,\n    password: string,\n    type: 'phone' | 'email',\n    username: string\n  }\n): Promise<boolean> => {\n  const action = 'resetPassword';\n  const {database} = context;\n  const formatPassword: string = parsePassword(password);\n  const aqlQuery: AqlQuery = aql`FOR u IN users\n    FILTER u.username == ${username}\n    LIMIT 1\n    RETURN u`;\n\n  try {\n    return await database.query(aqlQuery)\n      .then(async (cursor) => {\n        const user = cursor.next();\n\n        if(user) {\n          const {\n            _id: userDocId,\n            salt,\n            verifiedEmailCode,\n            verifiedEmailExpires,\n            verifiedPhoneCode,\n            verifiedPhoneExpires\n          } = user as UserType;\n          const now = Date.now();\n          let update;\n\n          switch(type) {\n            case 'email':\n              if(code === verifiedEmailCode && verifiedEmailExpires > now) {\n                const password: string = createPassword(formatPassword, salt);\n                update = {password};\n              }\n              break;\n            case 'phone':\n              if(code === verifiedPhoneCode && verifiedPhoneExpires > now) {\n                const password: string = createPassword(formatPassword, salt);\n                update = {password};\n              }\n              break;\n            default:\n              return false;\n          }\n\n          if(update) {\n            const updateQuery: AqlQuery = aql`UPDATE ${userDocId} WITH ${update} IN users`;\n\n            await database.query(updateQuery);\n\n            return true;\n          }\n        }\n\n        return false;\n      });\n  } catch(error) {\n    logError({\n      action,\n      category: eventCategory,\n      params: {username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n\n    return false;\n  }\n};\n\nexport const confirmCode = async (\n  context: ApiContext,\n  {\n    code,\n    type\n  }: {\n    code: number,\n    type: 'phone' | 'email'\n  }\n): Promise<boolean> => {\n  const action = 'confirmCode';\n  const {database, session: {userId: sessionId}} = context;\n  const userDocId = getDocId('users', {userId: sessionId});\n  const aqlQuery: AqlQuery = aql`LET u = DOCUMENT(${userDocId}) RETURN u`;\n\n  try {\n    return await database.query(aqlQuery)\n      .then((cursor) => cursor.next())\n      .then(({verifiedEmailCode, verifiedPhoneCode}: UserType) => {\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) {\n    logError({\n      action,\n      category: eventCategory,\n      params: {code, type},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n\n    return false;\n  }\n};\n\nexport const deleteUser = (context: ApiContext, user: UserType): Promise<UserType> => {\n  const action = 'deleteUser';\n  const {database} = context;\n  const {userId} = parseUser(user);\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  const stripeClient = new Stripe(Config.get('stripe.token'), {apiVersion: STRIPE_API_VERSION, typescript: true});\n\n  return database.query(aqlQuery)\n    .then((cursor) => cursor.next())\n    .then((deletedUser) => stripeClient.customers.del(deletedUser?.stripeCustomerId)\n      .then(() => stripeClient.accounts.del(deletedUser?.stripeAccountId))\n      .then(() => deletedUser))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {userId},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error,context));\n};\n\nexport const deactivateUser = (context: ApiContext, user: UserType): Promise<UserType> => {\n  const action = 'delete';\n  const {database} = context;\n  const {userId} = parseUser(user);\n  const updated: UserType = {\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) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {userId},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error,context));\n};\n\nexport const getDisplayName = (user: UserType): string => {\n  const {first, last, name = '', username = ''} = user;\n  const fullname = ([first, last]).join(' ').trim();\n\n  if(name) {\n    return name;\n  } else if(fullname !== '') {\n    return fullname;\n  } else if(username) {\n    return username;\n  }\n\n  return 'Unknown';\n};\n\nexport const getSessionUser = (context: ApiContext): Promise<UserType> => {\n  const action = 'getSessionUser';\n  console.log('getSessionUser', {action, context});\n  const {database, fields, session: {userId: sessionId, username}} = context;\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n  const formatSessionId = parseArangoId(`users/${sessionId}`);\n\n  const aqlQuery: string = `LET u = DOCUMENT(\"${formatSessionId}\")\n  ${selectQueries.join('\\n')}\n  RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQuery)\n    .then((cursor) => cursor.next() as unknown as UserType)\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        params: {userId: sessionId, username},\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return null;\n    });\n};\n\nexport const getUser = (context: ApiContext, user: UserType): Promise<UserType> => {\n  const action = 'getUser';\n  const {id, userId, username} = parseUser(user);\n  const {database, fields} = context;\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n  let aqlQuery: string;\n\n  console.log({id, userId, username});\n  if(id) {\n    aqlQuery = `LET u = DOCUMENT(\"${id}\")\n    ${selectQueries.join('\\n')}\n    FILTER u.userAccess > 0\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n  } else if(username) {\n    aqlQuery = `FOR u IN users\n    FILTER u.username == \"${username}\"\n    ${selectQueries.join('\\n')}\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n  }\n\n  return database.query(aqlQuery)\n    .then((cursor) => cursor.next())\n    .then((user) => user)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {id, userId, username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const getUsers = (context: ApiContext, options?: UserOptions): Promise<UserType[]> => {\n  const action = '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(username) {\n    filterBy.push(`CONTAINS(u.username, \"${parseUsername(username)}\")`);\n  }\n\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) => cursor.all() as unknown as UserType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as UserType[];\n    });\n};\n\nexport const getUsersByReactions = (\n  context: ApiContext,\n  {reactions = [], username},\n  options?: UserOptions\n): Promise<UserType[]> => {\n  const action = '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  const formatSessionId: string = `users/${sessionId}`;\n  const formatUsername: string = parseUsername(username);\n  const filterBy: string[] = [\n    'u.userAccess > 0',\n    `POSITION(${JSON.stringify(formatReactions)}, LOWER(r.name))`\n  ];\n\n  if(username) {\n    filterBy.push(`CONTAINS(u.username, \"${formatUsername}\")`);\n  }\n\n  const aqlQuery: string = `FOR u, r IN OUTBOUND \"${formatSessionId}\" hasReaction\n    OPTIONS {vertexCollections: \"users\"}\n    ${selectQueries.join('\\n')}\n    FILTER ${filterBy.join(' && ')}\n    ${limit.aql}\n    RETURN MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQuery)\n    .then((cursor) => cursor.all() as unknown as UserType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as UserType[];\n    });\n};\n\nexport const getUsersByTags = (\n  context: ApiContext,\n  {tags, username},\n  options?: UserOptions\n): Promise<UserType[]> => {\n  const action = 'getUsersByTags';\n  const {database, fields, session: {userId: sessionId}} = context;\n  const formatTags: string[] =  tags?.reduce((list: string[], tagName: string) => {\n    if(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  const formatUsername: string = parseUsername(username);\n  const filterBy: string[] = [\n    `u._key != \"${sessionId}\"`,\n    'u.userAccess > 0'\n  ];\n\n  if(username) {\n    filterBy.push(`CONTAINS(u.username, \"${formatUsername}\")`);\n  }\n\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    FILTER ${filterBy.join(' && ')}\n    ${limit.aql}\n    RETURN DISTINCT MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQuery)\n    .then((cursor) => cursor.all() as unknown as UserType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as UserType[];\n    });\n};\n\nexport const getUsersByLatest = (context: ApiContext, {username}, options?: UserOptions): Promise<UserType[]> => {\n  const action = 'getUsersByLatest';\n  const {database, fields, session: {userId}} = context;\n  const {limit} = parseUserOptions(options);\n  const filter = [\n    'u._id != session._id',\n    'u.userAccess > 0'\n  ];\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n\n  if(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) => cursor.all() as unknown as UserType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as UserType[];\n    });\n};\n\nexport const getUsersByConnection = (\n  context: ApiContext,\n  {userId}: UserType,\n  options?: UserOptions\n): Promise<UserType[]> => {\n  const action = 'getUsersByConnection';\n  const {database, fields} = context;\n  const {limit, username} = parseUserOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getUserOptional(fields);\n  const formatUserId: string = parseArangoId(`users/${userId}`);\n  const filterBy: string[] = [\n    'u.userAccess > 0'\n  ];\n\n  if(username) {\n    filterBy.push(`CONTAINS(u.username, \"${parseUsername(username)}\")`);\n  }\n\n  const aqlQuery: string = `FOR cu IN users\n    LET session = DOCUMENT(\"${formatUserId}\")\n    FOR u, connection IN OUTBOUND cu hasConnection\n    OPTIONS {bfs: true, uniqueVertices: \"global\", vertexCollections: \"users\"}\n    ${selectQueries.join('\\n')}\n    FILTER ${filterBy.join(' && ')}\n    ${limit.aql}\n    RETURN DISTINCT MERGE(u, {${selectObjects.join(', ')}})`;\n\n  return database.query(aqlQuery)\n    .then((cursor) => cursor.all() as unknown as UserType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n\n      return [] as UserType[];\n    });\n};\n\nexport const refreshSession = ({expires, token}): SessionToken | SessionError => {\n  try {\n    const {userId, username, userAccess} = getSession(token);\n    return createToken(userId, username, userAccess, expires);\n  } catch(error) {\n    throw error; // Re-throw the error from getSession\n  }\n};\n\nexport const signIn = async (context: ApiContext, args): Promise<SessionToken> => {\n  const action = 'signIn';\n  const {database} = context;\n  const {email, expires, password, phone, username} = args;\n  const formatEmail: string = parseEmail(email);\n  const formatUsername: string = parseUsername(username);\n  const formatPassword: string = parsePassword(password);\n  const formatPhone: string = parsePhone(phone);\n  const formatExpires: number = parseNum(expires) || 15;\n\n  if((!formatUsername && !formatEmail && !formatPhone) || !formatPassword) {\n    logException({\n      action,\n      category: eventCategory,\n      params: {username},\n      value: ErrorTypes.INVALID_ARGUMENTS\n    }, context);\n    return null;\n  }\n\n  const filters: string[] = [];\n\n  if(formatEmail) {\n    filters.push(`u.email == \"${formatEmail}\"`);\n  }\n\n  if(formatPhone) {\n    filters.push(`u.phone == ${formatPhone}`);\n  }\n\n  if(formatUsername) {\n    filters.push(`u.username == \"${formatUsername}\"`);\n  }\n\n  const checkQuery: string = `FOR u IN users\n    FILTER ${filters.join(' || ')}\n    LIMIT 1\n    RETURN u`;\n\n  let checkUser: UserType;\n\n  try {\n    checkUser = await database.query(checkQuery).then((cursor) => cursor.next());\n  } catch(error) {\n    logError({\n      action,\n      category: eventCategory,\n      params: {username: formatUsername},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n\n    return null;\n  }\n\n  if(!checkUser) {\n    logException({\n      action,\n      category: eventCategory,\n      params: {username},\n      value: ErrorTypes.INVALID_AUTHENTICATION\n    }, context);\n\n    return null;\n  }\n\n  const {_key: userId, password: validPassword, salt, userAccess} = checkUser;\n  const authPassword: string = createPassword(formatPassword, salt);\n\n  if(validPassword !== authPassword) {\n    logException({\n      action,\n      category: eventCategory,\n      params: {userAccess, userId, username},\n      value: ErrorTypes.INVALID_AUTHENTICATION\n    }, context);\n\n    return null;\n  }\n\n  try {\n    console.log({formatExpires, userAccess, userId, username});\n    const token = createToken(userId, username, userAccess, formatExpires);\n    console.log({token});\n\n    return token;\n  } catch(error) {\n    logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n\n    return null;\n  }\n};\n\nexport const signOut = async (context: ApiContext): Promise<boolean> => {\n  const action = '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).then((cursor) => cursor.next());\n  } catch(error) {\n    await logError({\n      action,\n      category: eventCategory,\n      params: {userId: sessionId, username},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context);\n  }\n\n  return true;\n};\n\nexport const getActiveUserCount = (context: ApiContext): Promise<number> => {\n  const action = '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      value: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const getUserByToken = (context: ApiContext, token: string): Promise<UserType> => {\n  const action = 'getUserByToken';\n  const {database} = context;\n  const {userId} = getSession(token);\n  const userDocId = getDocId('users', {userId});\n  const aqlQuery: AqlQuery = aql`LET u = DOCUMENT(\"${userDocId}\") RETURN u`;\n\n  return database.query(aqlQuery)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      params: {userId},\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAIA,mBAUO;AACP,sBAAkB;AAElB,mBAAuB;AACvB,oBAAmB;AAEnB,yBAAwB;AACxB,oBAAqB;AACrB,mBAAwB;AACxB,iBAAsB;AACtB,mBAAuC;AACvC,4BAAqC;AACrC,2BAA4D;AAC5D,qBAAgE;AAOhE,MAAM,gBAAgB;AACtB,MAAM,qBAAqB;AAQpB,IAAK,aAAL,kBAAKA,gBAAL;AACL,EAAAA,wBAAA,iBAAc,KAAd;AACA,EAAAA,wBAAA,YAAS,KAAT;AACA,EAAAA,wBAAA,aAAU,KAAV;AACA,EAAAA,wBAAA,mBAAgB,KAAhB;AACA,EAAAA,wBAAA,WAAQ,KAAR;AALU,SAAAA;AAAA,GAAA;AAQL,MAAM,cAAc,CACzB,QACA,UACA,YACA,mBAA2B,OACV;AACjB,QAAM,MAAgB,sBAAS,MAAM;AACrC,QAAM,iBAA2B,IAAI,KAAK,EAAC,SAAS,iBAAgB,CAAC;AACrE,QAAM,MAAc,KAAK,MAAM,IAAI,UAAU,CAAC;AAC9C,QAAM,MAAc,KAAK,MAAM,eAAe,UAAU,CAAC;AACzD,QAAM,YAAQ,2BAAW;AAAA,IACvB;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF,CAAC;AAED,SAAO;AAAA,IACL,SAAS,eAAe,SAAS;AAAA,IACjC,QAAQ,IAAI,SAAS;AAAA,IACrB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAOO,MAAM,kBAAkB,CAAC,SAAmB,CAAC,MAClD,OAAO,OAAO,CAAC,SAA4B,UAAkB;AAC3D,MAAG,MAAM,SAAS,OAAO,GAAG;AAC1B,eAAO,gDAA0B,SAAS,KAAK,OAAO,OAAO;AAAA,EAC/D;AAEA,SAAO;AACT,GAAG,EAAC,SAAS,CAAC,GAAG,SAAS,CAAC,EAAC,CAAC;AAExB,MAAM,mBAAmB,CAAC,UAAuB,CAAC,MAAM;AAC7D,QAAM;AAAA,IACJ,OAAO;AAAA,IACP,KAAK;AAAA,EACP,IAAI;AACJ,QAAM,YAAQ,+BAAS,MAAM,EAAE;AAE/B,SAAO;AAAA,IACL,GAAG;AAAA,IACH;AAAA,EACF;AACF;AAEO,MAAM,UAAU,OAAO,SAAqB,SAAsC;AACvF,QAAM,SAAS;AACf,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,EAAC,OAAO,UAAU,OAAO,SAAQ,QAAI,8BAAU,IAAI;AACzD,QAAM,qBAAyB,4BAAc,QAAQ;AACrD,QAAM,kBAAsB,yBAAW,KAAK;AAC5C,QAAM,kBAAsB,yBAAW,KAAK;AAC5C,QAAM,qBAAyB,4BAAc,QAAQ;AACrD,QAAM,cAAc,CAAC,CAAC;AACtB,QAAM,cAAc,CAAC,CAAC,kBAAkB,CAAC,CAAC,eAAe,CAAC,CAAC;AAE3D,MAAG,CAAC,eAAe,CAAC,aAAa;AAC/B,eAAO,oCAAa;AAAA,MAClB;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,SAAQ;AAAA,MACjB,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO;AAAA,EACZ;AAEA,QAAM,SAAS,kBAAkB,eAAe;AAChD,QAAM,WAAe,yBAAW,GAAG,MAAM,GAAG,cAAc,IAAI,IAAI;AAClE,QAAM,wBAAoB,6BAAe,gBAAgB,IAAI;AAC7D,QAAM,UAAoB,CAAC;AAE3B,MAAG,gBAAgB;AACjB,YAAQ,KAAK,kBAAkB,cAAc,GAAG;AAAA,EAClD;AAEA,MAAG,aAAa;AACd,YAAQ,KAAK,eAAe,WAAW,GAAG;AAAA,EAC5C;AAEA,MAAG,aAAa;AACd,YAAQ,KAAK,cAAc,WAAW,EAAE;AAAA,EAC1C;AAEA,QAAM,aAAqB;AAAA,aAChB,QAAQ,KAAK,MAAM,CAAC;AAAA;AAAA;AAI/B,MAAI;AACF,UAAM,gBAAgB,MAAM,SAAS,MAAM,UAAU,EAAE,KAAK,CAAC,WAAW,OAAO,IAAI,CAAC;AAEpF,QAAG,cAAc,QAAQ;AACvB,iBAAO,oCAAa;AAAA,QAClB;AAAA,QACA,UAAU;AAAA,QACV,QAAQ;AAAA,UACN,OAAO;AAAA,UACP,OAAO;AAAA,UACP,UAAU;AAAA,QACZ;AAAA,QACA,OAAO,wBAAW;AAAA,MACpB,GAAG,OAAO;AAAA,IACZ;AAAA,EACF,SAAQ,OAAO;AACb,eAAO,gCAAS;AAAA,MACd;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,SAAQ;AAAA,MACjB,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAAA,EACnB;AAEA,QAAM,oBAA4B,KAAK,MAAM,MAAU,KAAK,OAAO,IAAI,GAAO;AAC9E,QAAM,oBAA4B,KAAK,MAAM,MAAU,KAAK,OAAO,IAAI,GAAO;AAE9E,QAAM,SAAmB;AAAA,IACvB,UAAM,yBAAW,gBAAgB,IAAI;AAAA,IACrC,OAAO,KAAK,IAAI;AAAA,IAChB,OAAO;AAAA,IACP,UAAU,KAAK,IAAI;AAAA,IACnB,UAAU;AAAA,IACV,OAAO;AAAA,IACP;AAAA,IACA,YAAY;AAAA,IACZ,UAAU;AAAA,IACV,eAAe;AAAA,IACf;AAAA,IACA,eAAe;AAAA,IACf;AAAA,EACF;AAEA,QAAM,cAAwB,6BAAa,MAAM;AAEjD,SAAO,MAAM,SAAS,MAAM,WAAW,EACpC,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,MAAM,CAAC,cAAU,gCAAS;AAAA,IACzB;AAAA,IACA,UAAU;AAAA,IACV,QAAQ,EAAC,SAAQ;AAAA,IACjB,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,OAAO,CAAC;AACtB;AAEO,MAAM,aAAa,OAAO,SAAqB,SAAsC;AAC1F,QAAM,SAAS;AACf,QAAM,EAAC,UAAU,QAAO,IAAI;AAC5B,QAAM,EAAC,MAAM,KAAK,IAAI,OAAO,CAAC,GAAG,QAAQ,GAAG,QAAO,QAAI,8BAAU,IAAI;AAErE,MAAG,KAAC,4BAAY,OAAO,KAAM,SAAS,WAAW,QAAS;AACxD,eAAO,oCAAa;AAAA,MAClB;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,QAAO;AAAA,MAChB,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO;AAAA,EACZ;AAEA,QAAM,YAAsB,uCAAuB,EAAE;AAAA,oBACnC,OAAO;AAAA;AAGzB,MAAI;AACF,UAAM,cAAc,MAAM,SAAS,MAAM,SAAS,EAAE,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC;AAClF,UAAM,gBAAgC,SAAS,WAAW,UAAU;AAEpE,UAAM,QAAQ,IAAI,KAAK,IAAI,CAAC,EAAC,IAAI,UAAU,KAAI,MAAM;AACnD,YAAM,WAAqB;AAAA,6BACJ,QAAQ,iBAAiB,EAAE,kBAAkB,IAAI;AAAA;AAAA;AAIxE,aAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,KAAK,CAAC,YAAY;AACjB,YAAG,CAAC,CAAC,SAAS;AACZ,iBAAO;AAAA,QACT;AAEA,cAAM,OAAO;AAAA,UACX,OAAO;AAAA,UACP,UAAM,yBAAW,YAAY,QAAQ,IAAI,EAAE,EAAE;AAAA,UAC7C,KAAK;AAAA,UACL,OAAO,KAAK,IAAI;AAAA,UAChB;AAAA,QACF;AAEA,eAAO,cAAc,KAAK,MAAM,EAAC,WAAW,KAAI,CAAC,EAAE,KAAK,MAAM,IAAI;AAAA,MACpE,CAAC;AAAA,IACL,CAAC,CAAC;AAEF,WAAO;AAAA,EACT,SAAQ,OAAO;AACb,eAAO,gCAAS;AAAA,MACd;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,KAAI;AAAA,MACb,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAAA,EACnB;AACF;AAEO,MAAM,iBAAiB,OAAO,SAAqB,EAAC,OAAO,OAAO,SAAQ,MAAwB;AACvG,QAAM,SAAS;AACf,QAAM,EAAC,KAAK,SAAQ,IAAI;AACxB,QAAM,WAAqB;AAAA,wBACL,KAAK,kBAAkB,KAAK,qBAAqB,QAAQ;AAAA;AAAA;AAI/E,MAAI;AACF,WAAO,MAAM,SAAS,MAAM,QAAQ,EACjC,KAAK,OAAO,WAAW;AACtB,YAAM,OAAO,OAAO,KAAK;AAEzB,UAAG,MAAM;AACP,cAAM,EAAC,OAAAC,QAAO,OAAAC,QAAO,eAAe,cAAa,IAAI;AACrD,cAAM,cAAc,MAAO,KAAK;AAChC,cAAM,OAAO,KAAK,MAAM,MAAU,KAAK,OAAO,IAAI,GAAO;AACzD,cAAM,gBAAY,+BAAS,SAAS,IAAI;AACxC,YAAI;AAEJ,YAAGD,UAAS,eAAe;AACzB,sCAAU;AAAA,YACR;AAAA,YACA,MAAM,gBAAgB,IAAI;AAAA,UAC5B,CAAC;AACD,mBAAS,EAAC,mBAAmB,MAAM,sBAAsB,YAAW;AAAA,QACtE;AAEA,YAAGC,UAAS,eAAe;AACzB,kCAAQ;AAAA,YACN;AAAA,YACA,MAAM,gBAAgB,IAAI;AAAA,UAC5B,CAAC;AACD,mBAAS,EAAC,mBAAmB,MAAM,sBAAsB,YAAW;AAAA,QACtE;AAEA,YAAG,OAAO,qBAAqB,OAAO,mBAAmB;AACvD,gBAAM,cAAwB,6BAAa,SAAS,SAAS,MAAM;AAEnE,gBAAM,SAAS,MAAM,WAAW;AAEhC,iBAAO;AAAA,QACT;AAEA,eAAO;AAAA,MACT;AAEA,aAAO;AAAA,IACT,CAAC;AAAA,EACL,SAAQ,OAAO;AACb,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,OAAO,OAAO,SAAQ;AAAA,MAC/B,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO;AAAA,EACT;AACF;AAEO,MAAM,gBAAgB,OAC3B,SACA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,MAMqB;AACrB,QAAM,SAAS;AACf,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,qBAAyB,4BAAc,QAAQ;AACrD,QAAM,WAAqB;AAAA,2BACF,QAAQ;AAAA;AAAA;AAIjC,MAAI;AACF,WAAO,MAAM,SAAS,MAAM,QAAQ,EACjC,KAAK,OAAO,WAAW;AACtB,YAAM,OAAO,OAAO,KAAK;AAEzB,UAAG,MAAM;AACP,cAAM;AAAA,UACJ,KAAK;AAAA,UACL;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF,IAAI;AACJ,cAAM,MAAM,KAAK,IAAI;AACrB,YAAI;AAEJ,gBAAO,MAAM;AAAA,UACX,KAAK;AACH,gBAAG,SAAS,qBAAqB,uBAAuB,KAAK;AAC3D,oBAAMC,gBAAmB,6BAAe,gBAAgB,IAAI;AAC5D,uBAAS,EAAC,UAAAA,UAAQ;AAAA,YACpB;AACA;AAAA,UACF,KAAK;AACH,gBAAG,SAAS,qBAAqB,uBAAuB,KAAK;AAC3D,oBAAMA,gBAAmB,6BAAe,gBAAgB,IAAI;AAC5D,uBAAS,EAAC,UAAAA,UAAQ;AAAA,YACpB;AACA;AAAA,UACF;AACE,mBAAO;AAAA,QACX;AAEA,YAAG,QAAQ;AACT,gBAAM,cAAwB,6BAAa,SAAS,SAAS,MAAM;AAEnE,gBAAM,SAAS,MAAM,WAAW;AAEhC,iBAAO;AAAA,QACT;AAAA,MACF;AAEA,aAAO;AAAA,IACT,CAAC;AAAA,EACL,SAAQ,OAAO;AACb,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,SAAQ;AAAA,MACjB,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO;AAAA,EACT;AACF;AAEO,MAAM,cAAc,OACzB,SACA;AAAA,EACE;AAAA,EACA;AACF,MAIqB;AACrB,QAAM,SAAS;AACf,QAAM,EAAC,UAAU,SAAS,EAAC,QAAQ,UAAS,EAAC,IAAI;AACjD,QAAM,gBAAY,+BAAS,SAAS,EAAC,QAAQ,UAAS,CAAC;AACvD,QAAM,WAAqB,uCAAuB,SAAS;AAE3D,MAAI;AACF,WAAO,MAAM,SAAS,MAAM,QAAQ,EACjC,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,KAAK,CAAC,EAAC,mBAAmB,kBAAiB,MAAgB;AAC1D,cAAO,MAAM;AAAA,QACX,KAAK;AACH,iBAAO,SAAS;AAAA,QAClB,KAAK;AACH,iBAAO,SAAS;AAAA,QAClB;AACE,iBAAO;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACL,SAAQ,OAAO;AACb,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,MAAM,KAAI;AAAA,MACnB,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO;AAAA,EACT;AACF;AAEO,MAAM,aAAa,CAAC,SAAqB,SAAsC;AACpF,QAAM,SAAS;AACf,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,EAAC,OAAM,QAAI,8BAAU,IAAI;AAE/B,QAAM,WAAqB;AAAA,uBACN,MAAM;AAAA;AAAA;AAAA;AAK3B,QAAM,eAAe,IAAI,cAAAC,QAAO,qBAAO,IAAI,cAAc,GAAG,EAAC,YAAY,oBAAoB,YAAY,KAAI,CAAC;AAE9G,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,KAAK,CAAC,gBAAgB,aAAa,UAAU,IAAI,aAAa,gBAAgB,EAC5E,KAAK,MAAM,aAAa,SAAS,IAAI,aAAa,eAAe,CAAC,EAClE,KAAK,MAAM,WAAW,CAAC,EACzB,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,QAAQ,EAAC,OAAM;AAAA,IACf,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAM,OAAO,CAAC;AACrB;AAEO,MAAM,iBAAiB,CAAC,SAAqB,SAAsC;AACxF,QAAM,SAAS;AACf,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,EAAC,OAAM,QAAI,8BAAU,IAAI;AAC/B,QAAM,UAAoB;AAAA,IACxB,YAAY;AAAA,EACd;AACA,QAAM,WAAqB,6BAAa,MAAM,SAAS,OAAO;AAE9D,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,QAAQ,EAAC,OAAM;AAAA,IACf,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAM,OAAO,CAAC;AACrB;AAEO,MAAM,iBAAiB,CAAC,SAA2B;AACxD,QAAM,EAAC,OAAO,MAAM,OAAO,IAAI,WAAW,GAAE,IAAI;AAChD,QAAM,WAAY,CAAC,OAAO,IAAI,EAAG,KAAK,GAAG,EAAE,KAAK;AAEhD,MAAG,MAAM;AACP,WAAO;AAAA,EACT,WAAU,aAAa,IAAI;AACzB,WAAO;AAAA,EACT,WAAU,UAAU;AAClB,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEO,MAAM,iBAAiB,CAAC,YAA2C;AACxE,QAAM,SAAS;AACf,UAAQ,IAAI,kBAAkB,EAAC,QAAQ,QAAO,CAAC;AAC/C,QAAM,EAAC,UAAU,QAAQ,SAAS,EAAC,QAAQ,WAAW,SAAQ,EAAC,IAAI;AACnE,QAAM,EAAC,SAAS,eAAe,SAAS,cAAa,IAAI,gBAAgB,MAAM;AAC/E,QAAM,sBAAkB,4BAAc,SAAS,SAAS,EAAE;AAE1D,QAAM,WAAmB,qBAAqB,eAAe;AAAA,IAC3D,cAAc,KAAK,IAAI,CAAC;AAAA,qBACP,cAAc,KAAK,IAAI,CAAC;AAE3C,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,KAAK,CAAwB,EACrD,MAAM,CAAC,UAAiB;AACvB,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,QAAQ,WAAW,SAAQ;AAAA,MACpC,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO;AAAA,EACT,CAAC;AACL;AAEO,MAAM,UAAU,CAAC,SAAqB,SAAsC;AACjF,QAAM,SAAS;AACf,QAAM,EAAC,IAAI,QAAQ,SAAQ,QAAI,8BAAU,IAAI;AAC7C,QAAM,EAAC,UAAU,OAAM,IAAI;AAC3B,QAAM,EAAC,SAAS,eAAe,SAAS,cAAa,IAAI,gBAAgB,MAAM;AAC/E,MAAI;AAEJ,UAAQ,IAAI,EAAC,IAAI,QAAQ,SAAQ,CAAC;AAClC,MAAG,IAAI;AACL,eAAW,qBAAqB,EAAE;AAAA,MAChC,cAAc,KAAK,IAAI,CAAC;AAAA;AAAA,uBAEP,cAAc,KAAK,IAAI,CAAC;AAAA,EAC7C,WAAU,UAAU;AAClB,eAAW;AAAA,4BACa,QAAQ;AAAA,MAC9B,cAAc,KAAK,IAAI,CAAC;AAAA,uBACP,cAAc,KAAK,IAAI,CAAC;AAAA,EAC7C;AAEA,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,KAAK,CAACC,UAASA,KAAI,EACnB,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,QAAQ,EAAC,IAAI,QAAQ,SAAQ;AAAA,IAC7B,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,OAAO,CAAC;AACtB;AAEO,MAAM,WAAW,CAAC,SAAqB,YAA+C;AAC3F,QAAM,SAAS;AACf,QAAM,EAAC,UAAU,OAAM,IAAI;AAC3B,QAAM,EAAC,OAAO,SAAQ,IAAI,iBAAiB,OAAO;AAClD,QAAM,EAAC,SAAS,eAAe,SAAS,cAAa,IAAI,gBAAgB,MAAM;AAC/E,QAAM,WAAqB,CAAC,kBAAkB;AAE9C,MAAG,UAAU;AACX,aAAS,KAAK,6BAAyB,4BAAc,QAAQ,CAAC,IAAI;AAAA,EACpE;AAEA,QAAM,WAAmB;AAAA,aACd,SAAS,KAAK,MAAM,CAAC;AAAA,MAC5B,cAAc,KAAK,IAAI,CAAC;AAAA,MACxB,MAAM,GAAG;AAAA;AAAA,uBAEQ,cAAc,KAAK,IAAI,CAAC;AAE7C,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,IAAI,CAA0B,EACtD,MAAM,CAAC,UAAiB;AACvB,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO,CAAC;AAAA,EACV,CAAC;AACL;AAEO,MAAM,sBAAsB,CACjC,SACA,EAAC,YAAY,CAAC,GAAG,SAAQ,GACzB,YACwB;AACxB,QAAM,SAAS;AACf,QAAM,EAAC,UAAU,QAAQ,SAAS,EAAC,QAAQ,UAAS,EAAC,IAAI;AACzD,QAAM,kBAA6B,UAAU,IAAI,CAAC,qBAAyB,wBAAU,cAAc,EAAE,EAAE,YAAY,CAAC;AACpH,QAAM,EAAC,MAAK,IAAI,iBAAiB,OAAO;AACxC,QAAM,EAAC,SAAS,eAAe,SAAS,cAAa,IAAI,gBAAgB,MAAM;AAC/E,QAAM,kBAA0B,SAAS,SAAS;AAClD,QAAM,qBAAyB,4BAAc,QAAQ;AACrD,QAAM,WAAqB;AAAA,IACzB;AAAA,IACA,YAAY,KAAK,UAAU,eAAe,CAAC;AAAA,EAC7C;AAEA,MAAG,UAAU;AACX,aAAS,KAAK,yBAAyB,cAAc,IAAI;AAAA,EAC3D;AAEA,QAAM,WAAmB,yBAAyB,eAAe;AAAA;AAAA,MAE7D,cAAc,KAAK,IAAI,CAAC;AAAA,aACjB,SAAS,KAAK,MAAM,CAAC;AAAA,MAC5B,MAAM,GAAG;AAAA,uBACQ,cAAc,KAAK,IAAI,CAAC;AAE7C,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,IAAI,CAA0B,EACtD,MAAM,CAAC,UAAiB;AACvB,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO,CAAC;AAAA,EACV,CAAC;AACL;AAEO,MAAM,iBAAiB,CAC5B,SACA,EAAC,MAAM,SAAQ,GACf,YACwB;AACxB,QAAM,SAAS;AACf,QAAM,EAAC,UAAU,QAAQ,SAAS,EAAC,QAAQ,UAAS,EAAC,IAAI;AACzD,QAAM,aAAwB,MAAM,OAAO,CAAC,MAAgB,YAAoB;AAC9E,QAAG,SAAS;AACV,WAAK,SAAK,wBAAU,SAAS,EAAE,EAAE,YAAY,CAAC;AAAA,IAChD;AAEA,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AACL,QAAM,EAAC,MAAK,IAAI,iBAAiB,OAAO;AACxC,QAAM,EAAC,SAAS,eAAe,SAAS,cAAa,IAAI,gBAAgB,MAAM;AAC/E,QAAM,qBAAyB,4BAAc,QAAQ;AACrD,QAAM,WAAqB;AAAA,IACzB,cAAc,SAAS;AAAA,IACvB;AAAA,EACF;AAEA,MAAG,UAAU;AACX,aAAS,KAAK,yBAAyB,cAAc,IAAI;AAAA,EAC3D;AAEA,QAAM,WAAmB;AAAA,sBACL,KAAK,UAAU,UAAU,CAAC;AAAA;AAAA;AAAA,MAG1C,cAAc,KAAK,IAAI,CAAC;AAAA,aACjB,SAAS,KAAK,MAAM,CAAC;AAAA,MAC5B,MAAM,GAAG;AAAA,gCACiB,cAAc,KAAK,IAAI,CAAC;AAEtD,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,IAAI,CAA0B,EACtD,MAAM,CAAC,UAAiB;AACvB,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO,CAAC;AAAA,EACV,CAAC;AACL;AAEO,MAAM,mBAAmB,CAAC,SAAqB,EAAC,SAAQ,GAAG,YAA+C;AAC/G,QAAM,SAAS;AACf,QAAM,EAAC,UAAU,QAAQ,SAAS,EAAC,OAAM,EAAC,IAAI;AAC9C,QAAM,EAAC,MAAK,IAAI,iBAAiB,OAAO;AACxC,QAAM,SAAS;AAAA,IACb;AAAA,IACA;AAAA,EACF;AACA,QAAM,EAAC,SAAS,eAAe,SAAS,cAAa,IAAI,gBAAgB,MAAM;AAE/E,MAAG,UAAU;AACX,WAAO,KAAK,6BAAyB,4BAAc,QAAQ,CAAC,IAAI;AAAA,EAClE;AAGA,QAAM,WAAmB;AAAA,oCACS,MAAM;AAAA,aAC7B,OAAO,KAAK,MAAM,CAAC;AAAA,MAC1B,cAAc,KAAK,IAAI,CAAC;AAAA;AAAA,MAExB,MAAM,GAAG;AAAA;AAAA,uBAEQ,cAAc,KAAK,IAAI,CAAC;AAE7C,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,IAAI,CAA0B,EACtD,MAAM,CAAC,UAAiB;AACvB,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO,CAAC;AAAA,EACV,CAAC;AACL;AAEO,MAAM,uBAAuB,CAClC,SACA,EAAC,OAAM,GACP,YACwB;AACxB,QAAM,SAAS;AACf,QAAM,EAAC,UAAU,OAAM,IAAI;AAC3B,QAAM,EAAC,OAAO,SAAQ,IAAI,iBAAiB,OAAO;AAClD,QAAM,EAAC,SAAS,eAAe,SAAS,cAAa,IAAI,gBAAgB,MAAM;AAC/E,QAAM,mBAAuB,4BAAc,SAAS,MAAM,EAAE;AAC5D,QAAM,WAAqB;AAAA,IACzB;AAAA,EACF;AAEA,MAAG,UAAU;AACX,aAAS,KAAK,6BAAyB,4BAAc,QAAQ,CAAC,IAAI;AAAA,EACpE;AAEA,QAAM,WAAmB;AAAA,8BACG,YAAY;AAAA;AAAA;AAAA,MAGpC,cAAc,KAAK,IAAI,CAAC;AAAA,aACjB,SAAS,KAAK,MAAM,CAAC;AAAA,MAC5B,MAAM,GAAG;AAAA,gCACiB,cAAc,KAAK,IAAI,CAAC;AAEtD,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,IAAI,CAA0B,EACtD,MAAM,CAAC,UAAiB;AACvB,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO,CAAC;AAAA,EACV,CAAC;AACL;AAEO,MAAM,iBAAiB,CAAC,EAAC,SAAS,MAAK,MAAmC;AAC/E,MAAI;AACF,UAAM,EAAC,QAAQ,UAAU,WAAU,QAAI,2BAAW,KAAK;AACvD,WAAO,YAAY,QAAQ,UAAU,YAAY,OAAO;AAAA,EAC1D,SAAQ,OAAO;AACb,UAAM;AAAA,EACR;AACF;AAEO,MAAM,SAAS,OAAO,SAAqB,SAAgC;AAChF,QAAM,SAAS;AACf,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,EAAC,OAAO,SAAS,UAAU,OAAO,SAAQ,IAAI;AACpD,QAAM,kBAAsB,yBAAW,KAAK;AAC5C,QAAM,qBAAyB,4BAAc,QAAQ;AACrD,QAAM,qBAAyB,4BAAc,QAAQ;AACrD,QAAM,kBAAsB,yBAAW,KAAK;AAC5C,QAAM,oBAAwB,uBAAS,OAAO,KAAK;AAEnD,MAAI,CAAC,kBAAkB,CAAC,eAAe,CAAC,eAAgB,CAAC,gBAAgB;AACvE,4CAAa;AAAA,MACX;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,SAAQ;AAAA,MACjB,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO;AACV,WAAO;AAAA,EACT;AAEA,QAAM,UAAoB,CAAC;AAE3B,MAAG,aAAa;AACd,YAAQ,KAAK,eAAe,WAAW,GAAG;AAAA,EAC5C;AAEA,MAAG,aAAa;AACd,YAAQ,KAAK,cAAc,WAAW,EAAE;AAAA,EAC1C;AAEA,MAAG,gBAAgB;AACjB,YAAQ,KAAK,kBAAkB,cAAc,GAAG;AAAA,EAClD;AAEA,QAAM,aAAqB;AAAA,aAChB,QAAQ,KAAK,MAAM,CAAC;AAAA;AAAA;AAI/B,MAAI;AAEJ,MAAI;AACF,gBAAY,MAAM,SAAS,MAAM,UAAU,EAAE,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC;AAAA,EAC7E,SAAQ,OAAO;AACb,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,UAAU,eAAc;AAAA,MACjC,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO;AAAA,EACT;AAEA,MAAG,CAAC,WAAW;AACb,4CAAa;AAAA,MACX;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,SAAQ;AAAA,MACjB,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO;AAEV,WAAO;AAAA,EACT;AAEA,QAAM,EAAC,MAAM,QAAQ,UAAU,eAAe,MAAM,WAAU,IAAI;AAClE,QAAM,mBAAuB,6BAAe,gBAAgB,IAAI;AAEhE,MAAG,kBAAkB,cAAc;AACjC,4CAAa;AAAA,MACX;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,YAAY,QAAQ,SAAQ;AAAA,MACrC,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO;AAEV,WAAO;AAAA,EACT;AAEA,MAAI;AACF,YAAQ,IAAI,EAAC,eAAe,YAAY,QAAQ,SAAQ,CAAC;AACzD,UAAM,QAAQ,YAAY,QAAQ,UAAU,YAAY,aAAa;AACrE,YAAQ,IAAI,EAAC,MAAK,CAAC;AAEnB,WAAO;AAAA,EACT,SAAQ,OAAO;AACb,wCAAS;AAAA,MACP;AAAA,MACA,UAAU;AAAA,MACV,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAEjB,WAAO;AAAA,EACT;AACF;AAEO,MAAM,UAAU,OAAO,YAA0C;AACtE,QAAM,SAAS;AACf,QAAM,EAAC,UAAU,SAAS,EAAC,QAAQ,WAAW,SAAQ,EAAC,IAAI;AAC3D,QAAM,YAAoB,SAAS,SAAS;AAE5C,QAAM,SAAS;AAAA,IACb,YAAY,KAAK,IAAI;AAAA,IACrB,WAAW;AAAA,EACb;AACA,QAAM,eAAyB,uCAAuB,SAAS;AAAA,oBAC7C,MAAM;AAAA;AAAA;AAIxB,MAAI;AACF,UAAM,SAAS,MAAM,YAAY,EAAE,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC;AAAA,EACnE,SAAQ,OAAO;AACb,cAAM,gCAAS;AAAA,MACb;AAAA,MACA,UAAU;AAAA,MACV,QAAQ,EAAC,QAAQ,WAAW,SAAQ;AAAA,MACpC,OAAO,wBAAW;AAAA,IACpB,GAAG,OAAO,OAAO;AAAA,EACnB;AAEA,SAAO;AACT;AAEO,MAAM,qBAAqB,CAAC,YAAyC;AAC1E,QAAM,SAAS;AACf,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,aAAuB;AAAA;AAAA;AAAA;AAAA;AAAA;AAO7B,SAAO,SAAS,MAAM,UAAU,EAC7B,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,MAAM,CAAC,cAAU,gCAAS;AAAA,IACzB;AAAA,IACA,UAAU;AAAA,IACV,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,OAAO,CAAC;AACtB;AAEO,MAAM,iBAAiB,CAAC,SAAqB,UAAqC;AACvF,QAAM,SAAS;AACf,QAAM,EAAC,SAAQ,IAAI;AACnB,QAAM,EAAC,OAAM,QAAI,2BAAW,KAAK;AACjC,QAAM,gBAAY,+BAAS,SAAS,EAAC,OAAM,CAAC;AAC5C,QAAM,WAAqB,wCAAwB,SAAS;AAE5D,SAAO,SAAS,MAAM,QAAQ,EAC3B,KAAK,CAAC,WAAW,OAAO,KAAK,CAAC,EAC9B,MAAM,CAAC,cAAiB,gCAAS;AAAA,IAChC;AAAA,IACA,UAAU;AAAA,IACV,QAAQ,EAAC,OAAM;AAAA,IACf,OAAO,wBAAW;AAAA,EACpB,GAAG,OAAO,OAAO,CAAC;AACtB;",
  "names": ["UserAccess", "email", "phone", "password", "Stripe", "user"]
}
