@nlabs/reaktor 0.1.2 → 0.1.3

package/src/data/groups.ts

@@ -1,308 +0,0 @@
-import {createHash, parseChar, parseId} from '@nlabs/utils';
-import {aql, Database} from 'arangojs';
-import {AqlQuery} from 'arangojs/lib/cjs/aql-query';
-import {ArrayCursor} from 'arangojs/lib/cjs/cursor';
-import flatten from 'lodash/flatten';
-import uniqBy from 'lodash/uniqBy';
-
-import {ArangoDBLimit} from '../types/arangodb';
-import {ApiContext} from '../types/auth';
-import {GroupEdgeType, GroupType, GroupUserType} from '../types/groups';
-import {getLimit, logError, useDb} from '../utils';
-import {extractTags} from './tags';
-
-/**
- * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
- * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
- */
-
-const eventCategory: string = 'groups';
-
-export const getGroupList = (context: ApiContext, from: number, to: number): Promise<GroupType[]> => {
-  const action: string = 'getListByApp';
-  const {database} = context;
-  const limit: ArangoDBLimit = getLimit(from, to);
-  const aqlQry: string = `FOR g in groups
-      LET users = (
-        FOR u, l IN OUTBOUND g._id isGrouped
-        RETURN MERGE (u, {type:l.type})
-      )
-      ${limit.aql}
-      SORT g.added
-      RETURN DISTINCT MERGE(g, {users:users})`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.all())
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, context).then(() => null));
-};
-
-export const getGroupListByUser = (context: ApiContext, from: number, to: number): Promise<GroupType[]> => {
-  // const action: string = 'getListByUser';
-  const {database, userId: sessionId} = context;
-  const limit: ArangoDBLimit = getLimit(from, to);
-  const aqlQry: string = `FOR g, e IN INBOUND "${`users/${sessionId}`}" isGrouped
-      LET users = (
-        FOR u, l IN OUTBOUND g._id isGrouped
-        RETURN MERGE (u, {type:l.type})
-      )
-      ${limit.aql}
-      SORT g.added
-      RETURN DISTINCT MERGE(g, {users:users})`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.all())
-    .catch((error: Error) => {
-      throw error;
-    });
-};
-
-export const getGroupListByTags = (context: ApiContext, tags: string[], from: number, to: number): Promise<GroupType[]> => {
-  const action: string = 'getListByTags';
-  const {database} = context;
-
-  return Promise.all(
-    (tags || []).map((tagName: string) => {
-      const formatTagName: string = parseId(tagName);
-      const limit: ArangoDBLimit = getLimit(from, to);
-      const aqlQry: string = `FOR p, e IN OUTBOUND "${`tags/${formatTagName}`}" isTagged
-          FOR u IN users
-          LET likes = (
-            FOR post, like IN INBOUND p._id likes
-            FILTER like.value == 'like'
-            RETURN like
-          )
-          LET dislikes = (
-            FOR post, like IN INBOUND p._id likes
-            FILTER like.value == 'dislike'
-            RETURN like
-          )
-          FILTER e.type == 'post' && p.userId == u._key
-          ${limit.aql}
-          SORT p.added
-          RETURN DISTINCT MERGE(p, {user:u, likes:LENGTH(likes), dislikes:LENGTH(dislikes)})`;
-
-      return useDb(database).query(aqlQry).then((cursor: ArrayCursor) => cursor.all());
-    })
-  )
-    .then((results) => uniqBy(flatten(results), '_key'))
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, context).then(() => null));
-};
-
-export const getGroup = (context: ApiContext, itemId: string): Promise<GroupType> => {
-  const action: string = 'getItem';
-  const {database, userId: sessionId} = context;
-  const formatItemId: string = parseId(itemId);
-
-  const aqlQry: AqlQuery = aql`FOR g, e IN INBOUND ${`users/${sessionId}`} isGrouped
-      FILTER g._key == ${formatItemId}
-      LET users = (
-        FOR u, l IN OUTBOUND g._id isGrouped
-        RETURN MERGE (u, {type:l.type})
-      )
-      LIMIT 1
-      RETURN DISTINCT MERGE(g, {users:users})`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.next())
-    .then((group: GroupType = {}) => group)
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, context).then(() => null));
-};
-
-export const getGroupDetails = (context: ApiContext, groupId: string): Promise<GroupType> => {
-  const action: string = 'getDetails';
-  const {database} = context;
-  const formatGroupId: string = parseId(groupId);
-  const aqlQry: AqlQuery = aql`FOR g IN groups
-      FILTER g._key == ${formatGroupId}
-      LIMIT 1
-      RETURN g`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.next())
-    .then((group: GroupType = {}) => group)
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, context).then(() => null));
-};
-
-export const addGroup = (context: ApiContext, item: GroupType = {}): Promise<GroupType> => {
-  const action: string = 'add';
-  const {database, userId: sessionId} = context;
-  const now: number = Date.now();
-  const {
-    description = '',
-    name = 'Untitled',
-    type
-  }: GroupType = item;
-  const id: string = createHash(`group-${sessionId}`);
-  const formatDesc: string = description.substr(0, 640);
-  const formatType: string = parseChar(type, 16) || 'private';
-  const insert: GroupType = {
-    _key: id,
-    added: now,
-    description: formatDesc,
-    modified: now,
-    name,
-    type: formatType
-  };
-  const db: Database = useDb(database);
-  const aqlQry: AqlQuery = aql`INSERT ${insert} IN groups RETURN NEW`;
-
-  return db.query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.next())
-    .then((group: GroupType = {}) => {
-      const itemType: string = 'groups';
-
-      // Update linked tags
-      const {_key: groupId}: GroupType = group;
-      return extractTags(db, itemType, groupId, formatDesc)
-        .then(() => createGroupEdge(database, sessionId, groupId, 'admin').then(() => group));
-    })
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, context).then(() => null));
-};
-
-export const updateGroup = (context: ApiContext, item: GroupType = {}): Promise<GroupType> => {
-  const action: string = 'update';
-  const {database} = context;
-  const {
-    description = '',
-    id,
-    name = 'Untitled'
-  }: GroupType = item;
-  const itemId: string = parseId(id);
-  const now: number = Date.now();
-  const formatDesc: string = description.substr(0, 640);
-  const update: any = {
-    description: formatDesc,
-    modified: now,
-    name
-  };
-  const db: Database = useDb(database);
-  const aqlQry: AqlQuery = aql`UPDATE ${itemId} WITH ${update} IN groups RETURN NEW`;
-
-  return db.query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.next())
-    .then((group: GroupType = {}) => {
-      const {_key: groupKey} = group;
-      const itemType: string = 'groups';
-
-      // Update linked tags
-      return extractTags(db, itemType, groupKey, description).then(() => group);
-    })
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, context).then(() => null));
-};
-
-export const deleteGroup = (context: ApiContext, itemId: string): Promise<GroupType> => {
-  const action: string = 'delete';
-  const {database} = context;
-  const formatItemId: string = parseId(itemId);
-  const aqlQry: AqlQuery = aql`FOR g IN groups
-      FILTER g._key == ${formatItemId}
-      REMOVE g IN groups
-      RETURN OLD`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.next())
-    .then((group: GroupType = {}) => group)
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, context).then(() => null));
-};
-
-export const getGroupsByReaction = (context: ApiContext, reaction: string): Promise<GroupType[]> => {
-  const action: string = 'getGroupsByReaction';
-  const {database, userId: sessionId} = context;
-  const formatReaction: string = parseChar(reaction, 32);
-  const userDocId: string = `users/${sessionId}`;
-
-  // Query
-  const aqlQry: AqlQuery = aql`FOR u, r IN OUTBOUND ${userDocId} hasReaction
-      FILTER r.value == ${formatReaction}
-      COLLECT reactionName = r.value INTO reactionItems
-      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.all())
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, context).then(() => null));
-};
-
-export const isGrouped = (database: string, userId: string, groupId: string): Promise<GroupUserType> => {
-  const action: string = 'isGrouped';
-  const formatUserId: string = parseId(userId);
-  const formatGroupId: string = parseId(groupId);
-  const aqlQry: AqlQuery = aql`FOR g IN groups
-    FILTER g._key == ${formatGroupId}
-    FOR u IN INBOUND g._id isGrouped
-    FILTER u._key == ${formatUserId}
-    LIMIT 1
-    RETURN u`;
-
-  return useDb(database).query(aqlQry)
-    .then((cursor: ArrayCursor) => cursor.all())
-    .then((results = []) => {
-      const isValid = !!results.length;
-
-      return {
-        groupId,
-        isValid,
-        userId
-      };
-    })
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, {id: userId}).then(() => null));
-};
-
-export const createGroupEdge = (database: string, userId: string, groupId: string, type: string): Promise<GroupEdgeType> => {
-  const action: string = 'createGroupEdge';
-  const formatUserId: string = parseId(userId);
-  const formatGroupId: string = parseId(groupId);
-  const formatType: string = parseChar(type, 16);
-
-  const now: number = Date.now();
-  const edgeCollection = useDb(database).edgeCollection('isGrouped');
-  const edgeId: string = createHash(`group-${formatUserId}-${formatGroupId}`);
-
-  const edge: any = {
-    _key: edgeId,
-    added: now,
-    type: formatType
-  };
-
-  return edgeCollection.save(edge, `users/${formatUserId}`, `groups/${formatGroupId}`)
-    .catch((error: Error) => logError({
-      action,
-      category: eventCategory,
-      label: 'db_error'
-    }, error, {id: formatUserId}).then(() => null));
-};