@nlabs/reaktor 0.1.0 → 0.1.2

package/src/data/posts.ts

@@ -2,36 +2,86 @@
  * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
  * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
  */
-import {createHash, parseChar, parseId, parseString, parseVarChar} from '@nlabs/utils';
+import {createHash, parseChar, parseId, parseNum, parseString, parseVarChar} 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 {ApiContext, ArangoDBLimit, FileType, GroupType, PostType, TagType} from '../types';
+import {ApiContext, FileType, GroupType, PostOptions, PostType, TagType} from '../types';
 import {getLimit, useDb} from '../utils';
 import {updateFiles} from './files';
 import {extractTags} from './tags';
 
 // const eventCategory: string = 'posts';
+const MAX_CONTENT_LENGTH: number = 100000;
 
-export const getPostList = (context: ApiContext, from: number, to: number): Promise<PostType[]> => {
+export const parsePostOptions = (options: PostOptions = {}) => {
+  const {
+    from = 0,
+    latitude,
+    longitude,
+    to = 30,
+    type = 'default'
+  } = options;
+
+
+  return {
+    latitude: parseNum(latitude, 32),
+    longitude: parseNum(longitude, 32),
+    limit: getLimit(from, to),
+    type: parseChar(type, 32)
+  };
+};
+
+export const getPostOptional = (fields: string[]) =>
+  fields.reduce((selects: any, field: string) => {
+    switch(field) {
+      case 'reactions': {
+        selects.queries.push(`LET reactions = (
+          FOR post, r IN INBOUND p._id reactions
+          COLLECT reactionName = r.value INTO reactionItems
+          RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+        )`);
+        selects.objects.push('reactions:reactions');
+        return selects;
+      }
+      case 'tags': {
+        selects.queries.push(`LET tags = (
+          FOR t, pl IN INBOUND p._id isTagged
+          RETURN t
+        )`);
+        selects.objects.push('tags:tags');
+        return selects;
+      }
+      case 'user': {
+        selects.queries.push(`LET user = FIRST(
+          FOR u IN users
+          FILTER p.userId == u._key
+          LIMIT 1
+          RETURN u
+        )`);
+        selects.objects.push('user:user');
+        return selects;
+      }
+      default: {
+        return selects;
+      }
+    }
+  }, {objects: [], queries: []});
+
+export const getPostList = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {
   // const action: string = 'getListByApp';
-  const {database} = context;
-  const limit: ArangoDBLimit = getLimit(from, to);
+  const {database, fields} = context;
+  const {limit, type} = parsePostOptions(options);
+  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
   const aqlQry: string = `FOR p IN posts
-      FILTER !!p.parent == false
-      LET reactions = (
-        FOR post, r IN INBOUND p._id reactions
-        COLLECT reactionName = r.value INTO reactionItems
-        RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-      )
-      FOR u IN users
-      FILTER p.userId == u._key
-      ${limit.aql}
-      SORT p.added
-      RETURN DISTINCT MERGE(p, {user:u, reactions:reactions})`;
+    FILTER p.type == "${type}" && p.privacy == "public" && p.parent == null
+    ${selectQueries.join('\n')}
+    ${limit.aql}
+    SORT p.added
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
 
   return useDb(database).query(aqlQry)
     .then((cursor: ArrayCursor) => cursor.all())
@@ -40,9 +90,10 @@ export const getPostList = (context: ApiContext, from: number, to: number): Prom
     });
 };
 
-export const getPostListByGroup = (context: ApiContext, groupId: string, from: number, to: number): Promise<PostType[]> => {
+export const getPostListByGroup = (context: ApiContext, groupId: string, options?: PostOptions): Promise<PostType[]> => {
   // const action: string = 'getListByGroup';
-  const {database, userId: sessionId} = context;
+  const {database, fields, userId: sessionId} = context;
+  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
 
   // Group id
   const formatGroupId: string = parseId(groupId);
@@ -55,19 +106,13 @@ export const getPostListByGroup = (context: ApiContext, groupId: string, from: n
     .then((cursor: ArrayCursor) => cursor.all())
     .then((groups: GroupType[] = []) => {
       if(groups.length) {
-        const limit: ArangoDBLimit = getLimit(from, to);
+        const {limit, type} = parsePostOptions(options);
         const postAqlQry: string = `FOR p IN posts
-            FILTER p.groupId == "${formatGroupId}" && !!p.parent == false
-            LET reactions = (
-              FOR post, r IN INBOUND p._id reactions
-              COLLECT reactionName = r.value INTO reactionItems
-              RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-            )
-            FOR u IN users
-            FILTER p.userId == u._key
-            ${limit.aql}
-            SORT p.added
-            RETURN DISTINCT MERGE(p, {user:u, reactions:reactions})`;
+          FILTER p.type == "${type}" && p.groupId == "${formatGroupId}" && p.parent == null
+          ${selectQueries.join('\n')}
+          ${limit.aql}
+          SORT p.added
+          RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
 
         return db.query(postAqlQry)
           .then((cursor: ArrayCursor) => cursor.all())
@@ -83,22 +128,17 @@ export const getPostListByGroup = (context: ApiContext, groupId: string, from: n
     });
 };
 
-export const getPostListByLatest = (context: ApiContext, from: number, to: number): Promise<PostType[]> => {
+export const getPostListByLatest = (context: ApiContext, options?: PostOptions): Promise<PostType[]> => {
   // const action: string = 'getListByLatest';
-  const {database} = context;
-  const limit: ArangoDBLimit = getLimit(from, to);
+  const {database, fields} = context;
+  const {limit, type} = parsePostOptions(options);
+  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
   const aqlQry: string = `FOR p IN posts
-      FILTER p.privacy == "public" && !!p.parent == false
-      LET reactions = (
-        FOR post, r IN INBOUND p._id reactions
-        COLLECT reactionName = r.value INTO reactionItems
-        RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-      )
-      FOR u IN users
-      FILTER p.userId == u._key
-      ${limit.aql}
-      SORT p.added
-      RETURN DISTINCT MERGE(p, {user:u, reactions:reactions})`;
+    FILTER p.type == "${type}" && p.privacy == "public" && p.parent == null
+    ${selectQueries.join('\n')}
+    ${limit.aql}
+    SORT p.added
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
 
   return useDb(database).query(aqlQry)
     .then((cursor: ArrayCursor) => cursor.all())
@@ -107,31 +147,47 @@ export const getPostListByLatest = (context: ApiContext, from: number, to: numbe
     });
 };
 
-export const getPostListByTags = (context: ApiContext, tagNames: string[], from?: number, to?: number): Promise<PostType[]> => {
+export const getPostListByTags = (
+  context: ApiContext,
+  tagNames: string[],
+  options?: PostOptions
+): Promise<PostType[]> => {
   // const action: string = 'getListByTags';
-  const {database} = context;
+  const {database, fields} = context;
+  const {latitude, longitude, limit, type} = parsePostOptions(options);
+  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
+  const sortBy: string[] = [];
+
+  if(latitude !== undefined && longitude !== undefined) {
+    const formatLatitude: number = parseNum(latitude);
+    const formatLongitude: number = parseNum(longitude);
+    selectQueries.push(`LET distance = DISTANCE(
+      ${formatLatitude},
+      ${formatLongitude},
+      NOT_NULL(p.latitude, 0),
+      NOT_NULL(p.longitude, 0))
+    `);
+    selectObjects.push('distance:distance');
+    sortBy.push('distance');
+  }
+
+  sortBy.push('p.added');
 
   return Promise.all(
     tagNames.map((tagName: string) => {
-      const formatTagId: string = createHash(`tag-${tagName}`, null);
-      const limit: ArangoDBLimit = getLimit(from, to);
-      const aqlQry: string = `FOR p, e IN OUTBOUND "${`tags/${formatTagId}`}" isTagged
-          FOR u IN users
-          LET reactions = (
-            FOR post, r IN INBOUND p._id reactions
-            COLLECT reactionName = r.value INTO reactionItems
-            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-          )
-          FILTER e.type == 'posts' && p.userId == u._key
-          ${limit.aql}
-          SORT p.added
-          RETURN DISTINCT MERGE(p, {user:u, reactions:reactions})`;
-
+      const aqlQry: string = `FOR targetTag IN tags
+        FILTER targetTag.name == "${tagName}"
+        FOR p, e IN OUTBOUND targetTag._id isTagged
+        ${selectQueries.join('\n')}
+        FILTER p.type = "${type}" && p.privacy == "public" && e.type == 'posts'
+        ${limit.aql}
+        SORT ${sortBy.join(', ')}
+        RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+
+      console.log(aqlQry);
       return useDb(database).query(aqlQry)
         .then((cursor: ArrayCursor) => cursor.all())
-        .catch((error: Error) => {
-          throw error;
-        });
+        .catch(() => []);
     }))
     .then((results) => uniqBy(flatten(results), '_key'))
     .catch((error: Error) => {
@@ -139,23 +195,52 @@ export const getPostListByTags = (context: ApiContext, tagNames: string[], from?
     });
 };
 
-export const getPostListByUser = (context: ApiContext, userId: string, from: number, to: number): Promise<PostType[]> => {
+export const getPostListByUser = (context: ApiContext, userId: string, options?: PostOptions): Promise<PostType[]> => {
   // const action: string = 'getListByUser';
-  const {database} = context;
+  const {database, fields} = context;
+  const {limit, type} = parsePostOptions(options);
   const formatUserId: string = parseId(userId);
-  const limit: ArangoDBLimit = getLimit(from, to);
+  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
+  const aqlQry: string = `FOR p IN posts
+    FILTER p.userId == "${formatUserId}" && p.type == "${type}" && p.privacy == "public" && p.parent == null
+    ${selectQueries.join('\n')}
+    ${limit.aql}
+    SORT p.added
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
+
+  return useDb(database).query(aqlQry)
+    .then((cursor: ArrayCursor) => cursor.all())
+    .catch((error: Error) => {
+      throw error;
+    });
+};
+
+export const getPostListByArea = (
+  context: ApiContext,
+  latitude: number,
+  longitude: number,
+  options?: PostOptions
+): Promise<PostType[]> => {
+  // const action: string = 'getListByUser';
+  const {database, fields} = context;
+  const {limit, type} = parsePostOptions(options);
+  const formatLatitude: number = parseNum(latitude);
+  const formatLongitude: number = parseNum(longitude);
+  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
+  selectQueries.push(`LET distance = DISTANCE(
+    ${formatLatitude},
+    ${formatLongitude},
+    NOT_NULL(p.latitude, 0),
+    NOT_NULL(p.longitude, 0))
+  `);
+  selectObjects.push('distance:distance');
+
   const aqlQry: string = `FOR p IN posts
-      FILTER p.userId == "${formatUserId}" && !!p.parent == false
-      LET reactions = (
-        FOR post, r IN INBOUND p._id reactions
-        COLLECT reactionName = r.value INTO reactionItems
-        RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-      )
-      FOR u IN users
-      FILTER p.userId == u._key
-      ${limit.aql}
-      SORT p.added
-      RETURN DISTINCT MERGE(p, {user:u, reactions:reactions})`;
+    ${selectQueries.join('\n')}
+    FILTER p.type == "${type}" && p.privacy == "public" && p.parentId == null
+    ${limit.aql}
+    SORT distance, p.added
+    RETURN DISTINCT MERGE(p, {${selectObjects.join(', ')}})`;
 
   return useDb(database).query(aqlQry)
     .then((cursor: ArrayCursor) => cursor.all())
@@ -166,13 +251,14 @@ export const getPostListByUser = (context: ApiContext, userId: string, from: num
 
 export const getPost = (context: ApiContext, itemId: string): Promise<PostType> => {
   // const action: string = 'getItem';
-  const {database, userId: sessionId} = context;
+  const {database, fields, userId: sessionId} = context;
   const formatItemId: string = parseId(itemId);
   const db = useDb(database);
+  const {objects: selectObjects, queries: selectQueries} = getPostOptional(fields);
   const aqlQry: AqlQuery = aql`FOR p IN posts
-      FILTER p._key == ${formatItemId}
-      LIMIT 1
-      RETURN p`;
+    FILTER p._key == ${formatItemId}
+    LIMIT 1
+    RETURN p`;
 
   return db.query(aqlQry)
     .then((cursor: ArrayCursor) => cursor.next())
@@ -184,34 +270,24 @@ export const getPost = (context: ApiContext, itemId: string): Promise<PostType>
       }: PostType = post;
 
       // Query based on privacy level
-      let privacyAqlQry: AqlQuery;
+      let privacyAqlQry: string;
 
       if(groupId && privacy === 'group') {
-        privacyAqlQry = aql`FOR p IN posts
-          FOR user IN users
-          FILTER p._key == ${_key} && user._key == p.userId
-          LET reactions = (
-            FOR post, r IN INBOUND p._id reactions
-            COLLECT reactionName = r.value INTO reactionItems
-            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-          )
+        privacyAqlQry = `FOR p IN posts
+          FILTER p._key == "${_key}"
+          ${selectQueries.join('\n')}
           FOR group IN groups
           FILTER group._key == p.groupId
           FOR u, e IN OUTBOUND group._id isGrouped
           FILTER u._key == ${sessionId}
           LIMIT 1
-          RETURN MERGE(p, {user: user, reactions: reactions})`;
+          RETURN MERGE(p, {${selectObjects.join(', ')}})`;
       } else if(privacy === 'public') {
-        privacyAqlQry = aql`FOR p IN posts
-          FOR user IN users
-          FILTER p._key == ${_key} && user._key == p.userId
-          LET reactions = (
-            FOR post, r IN INBOUND p._id reactions
-            COLLECT reactionName = r.value INTO reactionItems
-            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-          )
+        privacyAqlQry = `FOR p IN posts
+          FILTER p._key == "${_key}"
+          ${selectQueries.join('\n')}
           LIMIT 1
-          RETURN MERGE(p, {user: user, reactions: reactions})`;
+          RETURN MERGE(p, {${selectObjects.join(', ')}})`;
       }
 
       if(privacyAqlQry) {
@@ -230,17 +306,18 @@ export const getPost = (context: ApiContext, itemId: string): Promise<PostType>
     });
 };
 
-export const getPostComments = (context: ApiContext, itemId: string, from: number, to: number): Promise<PostType[]> => {
+export const getPostComments = (context: ApiContext, itemId: string, options?: PostOptions): Promise<PostType[]> => {
   // const action: string = 'getComments';
   const {database, userId: sessionId} = context;
+  const {limit, type} = parsePostOptions(options);
   const formatItemId: string = parseId(itemId);
 
   // Get the parent post to get restrictions
   const db = useDb(database);
   const aqlQry: AqlQuery = aql`FOR p IN posts
-      FILTER p._key == ${formatItemId}
-      LIMIT 1
-      RETURN p`;
+    FILTER p.type == ${type} && p._key == ${formatItemId}
+    LIMIT 1
+    RETURN p`;
 
   return db.query(aqlQry)
     .then((cursor: ArrayCursor) => cursor.next())
@@ -253,36 +330,35 @@ export const getPostComments = (context: ApiContext, itemId: string, from: numbe
 
       // Query based on privacy level
       let privacyAqlQry: string;
-      const limit = getLimit(from, to);
 
       if(groupId && privacy === 'group') {
         privacyAqlQry = `FOR p IN posts
-            FOR user IN users
-            FILTER p.parent == "${_key}" && user._key == p.userId
-            LET reactions = (
-              FOR post, r IN INBOUND p._id reactions
-              COLLECT reactionName = r.value INTO reactionItems
-              RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-            )
-            FOR group IN groups
-            FILTER group._key == p.groupId
-            FOR u, e IN OUTBOUND group._id isGrouped
-            FILTER u._key == "${sessionId}"
-            SORT p.added
-            ${limit.aql}
-            RETURN MERGE(p, {user: user, reactions: reactions})`;
+          FOR user IN users
+          FILTER p.parent == "${_key}" && user._key == p.userId
+          LET reactions = (
+            FOR post, r IN INBOUND p._id reactions
+            COLLECT reactionName = r.value INTO reactionItems
+            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+          )
+          FOR group IN groups
+          FILTER group._key == p.groupId
+          FOR u, e IN OUTBOUND group._id isGrouped
+          FILTER u._key == "${sessionId}"
+          SORT p.added
+          ${limit.aql}
+          RETURN MERGE(p, {user: user, reactions: reactions})`;
       } else if(privacy === 'public') {
         privacyAqlQry = `FOR p IN posts
-            FOR user IN users
-            FILTER p.parent == "${_key}" && user._key == p.userId
-            LET reactions = (
-              FOR post, r IN INBOUND p._id reactions
-              COLLECT reactionName = r.value INTO reactionItems
-              RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
-            )
-            SORT p.added
-            ${limit.aql}
-            RETURN MERGE(p, {user: user, reactions: reactions})`;
+          FOR user IN users
+          FILTER p.parent == "${_key}" && user._key == p.userId
+          LET reactions = (
+            FOR post, r IN INBOUND p._id reactions
+            COLLECT reactionName = r.value INTO reactionItems
+            RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)}
+          )
+          SORT p.added
+          ${limit.aql}
+          RETURN MERGE(p, {user: user, reactions: reactions})`;
       }
 
       if(privacyAqlQry) {
@@ -305,12 +381,15 @@ export const addPost = (context: ApiContext, item: PostType): Promise<PostType>
   const {database, userId: sessionId} = context;
 
   const {
+    content = '',
     groupId = '',
+    location,
+    latitude,
+    longitude,
     name = '',
-    parentId = '',
+    parentId = null,
     privacy = 'public',
-    text = '',
-    title = ''
+    type = 'default'
   }: PostType = item;
 
   const now: number = Date.now();
@@ -318,15 +397,19 @@ export const addPost = (context: ApiContext, item: PostType): Promise<PostType>
   const insert: PostType = {
     _key: createHash(`post-${sessionId}`),
     added: now,
-    groupId: parseId(groupId),
+    content: parseString(content, MAX_CONTENT_LENGTH),
+    groupId: groupId ? parseId(groupId) : undefined,
+    latitude: latitude !== undefined ? parseNum(latitude) : undefined,
+    location: location ? parseString(location, 160) : undefined,
+    longitude: longitude !== undefined ? parseNum(longitude) : undefined,
     modified: now,
     name: parseString(name, 160),
-    parentId: parseId(parentId),
-    privacy: parseVarChar(privacy, 16),
-    text: parseString(text, 20000),
-    title: parseString(title, 160),
+    parentId: parentId ? parseId(parentId) : undefined,
+    privacy: privacy ? parseVarChar(privacy, 16) : undefined,
+    type: parseChar(type, 32),
     userId: sessionId
   };
+
   const db: Database = useDb(database);
   const aqlQry: AqlQuery = aql`INSERT ${insert} IN posts RETURN NEW`;
 
@@ -336,7 +419,7 @@ export const addPost = (context: ApiContext, item: PostType): Promise<PostType>
       const {_key: postKey} = post;
 
       // Update linked tags within posts
-      return extractTags(db, 'posts', postKey, insert.text)
+      return extractTags(db, 'posts', postKey, insert.content)
         .then((tagList: TagType[]) => {
           post.tags = tagList;
           return post;
@@ -352,36 +435,25 @@ export const updatePost = (context: ApiContext, item: PostType): Promise<PostTyp
   const {database, userId: sessionId} = context;
   const now: number = Date.now();
   const {
+    content,
     groupId,
-    id,
     name,
     parentId,
+    postId,
     privacy,
-    text
+    type
   }: PostType = item;
 
-  const updatedPost: PostType = {
-    modified: now
+  const update: PostType = {
+    content: content ? parseString(content, MAX_CONTENT_LENGTH) : undefined,
+    modified: now,
+    name: name ? parseString(name, 160) : undefined,
+    parentId: parentId ? parseString(parentId, 160) : undefined,
+    privacy: privacy ? parseVarChar(privacy, 16) : undefined,
+    type: type !== undefined ? parseChar(type, 16) : undefined
   };
 
-  if(name) {
-    updatedPost.name = parseString(name, 160);
-  }
-
-  if(text) {
-    updatedPost.text = parseString(text, 640);
-  }
-
-  if(privacy) {
-    updatedPost.privacy = parseVarChar(privacy, 16);
-  }
-
-  if(parent) {
-    updatedPost.parentId = parseId(parentId);
-  }
-  const update: any = updatedPost;
-
-  let formatId: string = parseId(id);
+  let formatId: string = parseId(postId);
   formatId = formatId === '' ? createHash(`post-${sessionId}`) : formatId;
   const formatGroupId: string = parseId(groupId);
   const insert: any = {
@@ -393,10 +465,10 @@ export const updatePost = (context: ApiContext, item: PostType): Promise<PostTyp
     userId: sessionId
   };
   const db: Database = useDb(database);
-  const aqlQry: AqlQuery = aql`UPSERT {_key: ${id}, userId: ${sessionId}}
-      INSERT ${insert}
-      UPDATE ${update}
-      IN posts RETURN NEW`;
+  const aqlQry: AqlQuery = aql`UPSERT {_key: ${formatId}, userId: ${sessionId}}
+    INSERT ${insert}
+    UPDATE ${update}
+    IN posts RETURN NEW`;
 
   return db.query(aqlQry)
     .then((cursor: ArrayCursor) => cursor.next())
@@ -404,7 +476,7 @@ export const updatePost = (context: ApiContext, item: PostType): Promise<PostTyp
       const {_key: updatedPostKey} = updatedPost;
 
       // Update linked tags
-      return extractTags(db, 'posts', updatedPostKey, update.text || '')
+      return extractTags(db, 'posts', updatedPostKey, update.content || '')
         .then((tagList = []) => {
           updatedPost.tags = tagList;
 
@@ -412,7 +484,7 @@ export const updatePost = (context: ApiContext, item: PostType): Promise<PostTyp
           const files: FileType[] = updatedPost.files || [];
 
           if(files.length) {
-            return updateFiles(db, id, files)
+            return updateFiles(db, formatId, files)
               .then((fileList = []) => {
                 updatedPost.files = fileList;
                 return updatedPost;
@@ -475,7 +547,7 @@ export const deletePost = (context: ApiContext, itemId: string): Promise<PostTyp
 export const cleanPosts = (database: string): Promise<number> => {
   // Remove all messages that are over 60 days and not saved
   const aqlQry: AqlQuery = aql`FOR p IN posts
-      FILTER p.added < DATE_TIMESTAMP(DATE_SUBTRACT(DATE_NOW(), 60, 'day')) && p.type == 1
+      FILTER p.added < DATE_TIMESTAMP(DATE_SUBTRACT(DATE_NOW(), 60, 'day')) && p.type == "default"
       REMOVE p IN posts
       RETURN OLD`;
 

package/src/data/users.ts

@@ -207,13 +207,11 @@ export const getUsersByRelations = (
   const formatUserId: string = parseId(userId);
   const formatType: string = parseChar(type, 32);
   const limit = getLimit(from, to);
-  console.log('context', context);
   const aqlQry: string = `FOR u, r IN INBOUND "${`users/${formatUserId}`}" hasRelation
     FILTER r.type == "${formatType}"
     ${limit.aql}
     RETURN u`;
 
-  console.log('getUsersByRelations::aqlQry', aqlQry);
   return useDb(database).query(aqlQry)
     .then((cursor: ArrayCursor) => cursor.all())
     .catch((error: Error) => logError({

package/src/types/apps.ts

@@ -11,7 +11,6 @@ export interface TestType {
 export interface AppSessionType {
   readonly active?: boolean;
   readonly added?: number;
-  readonly appId?: string;
   readonly exp?: number;
   readonly modified?: number;
   readonly name?: string;

package/src/types/auth.ts

@@ -6,6 +6,7 @@ export interface ApiContext {
   readonly appId: string;
   readonly database: string;
   readonly email: string;
+  readonly fields?: string[];
   readonly ipAddress: string;
   readonly userId: string;
   readonly username: string;

package/src/types/files.ts

@@ -5,7 +5,6 @@
 export interface FileType {
   readonly _key?: string;
   readonly added?: number;
-  readonly appId?: string;
   readonly base64?: string;
   readonly buffer?: Buffer;
   readonly description?: string;
@@ -26,7 +25,6 @@ export interface FileDecodedType {
 }
 
 export interface FileEdgeType {
-  readonly appId?: string;
   readonly imgId?: string;
   readonly itemId?: string;
   readonly itemType?: string;

package/src/types/groups.ts

@@ -5,7 +5,6 @@
 export interface GroupType {
   readonly _key?: string;
   readonly added?: number;
-  readonly appId?: string;
   readonly description?: string;
   readonly groupId?: string;
   readonly id?: string;

package/src/types/images.ts

@@ -23,7 +23,6 @@ export interface ImageIdentifyType {
 export type ImageUrlTypes = 'app' | 'events' | 'groups' | 'users';
 
 export interface ImageUrlData {
-  readonly appId?: string;
   readonly directory?: string;
   readonly imgId?: string;
   readonly imgType?: string;

package/src/types/locations.ts

@@ -6,7 +6,6 @@ export interface LocationType {
   readonly _key?: string;
   readonly address?: string;
   readonly added?: number;
-  readonly appId?: string;
   readonly city?: string;
   readonly country?: string;
   readonly description?: string;