@nlabs/reaktor 0.10.5 → 0.10.7

package/lib/actions/files.js

@@ -0,0 +1,226 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { get as httpGet } from '@nlabs/rip-hunter';
+import { createHash } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { google } from 'googleapis';
+import { parseFile } from '../adapters/fileAdapter.js';
+import { Config } from '../config.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+import { useDb } from '../utils/arangodbUtils.js';
+import { resizeSaveImage } from './images.js';
+import { createPostEdge } from './posts.js';
+const eventCategory = 'files';
+export const GIPHY_URL = 'http://api.giphy.com/v1/gifs';
+export const getYouTube = ()=>google.youtube({
+        auth: Config.get('google.key'),
+        version: 'v3'
+    });
+export const insertFile = (context, file)=>{
+    const action = 'insertFile';
+    const { databaseName } = context;
+    const formattedFile = parseFile(file);
+    const aqlQry = aql`INSERT ${formattedFile} IN files RETURN NEW`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+export const upsertFile = (context, file)=>{
+    const action = 'upsertFile';
+    const { databaseName } = context;
+    const formattedFile = parseFile(file);
+    const { fileId } = formattedFile;
+    const insert = {
+        ...formattedFile,
+        _key: fileId,
+        added: Date.now(),
+        modified: Date.now()
+    };
+    const update = {
+        ...formattedFile,
+        _key: fileId,
+        modified: Date.now()
+    };
+    const aqlQry = aql`UPSERT {_key: ${fileId}}
+    INSERT ${insert}
+    UPDATE ${update}
+    IN files RETURN NEW`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((updatedFile)=>updatedFile).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+export const uploadFile = (context, file, buffer)=>{
+    const { session: { userId: sessionId } } = context;
+    const formattedFile = parseFile(file);
+    const { description, fileId, fileType, name, url } = formattedFile;
+    const now = Date.now();
+    const formatFileId = fileId || createHash(`file-${sessionId}`);
+    let updatedName = name;
+    if (!updatedName && !!url) {
+        updatedName = url.substring(url.lastIndexOf('/') + 1);
+    }
+    if (fileType === 'image/jpeg' || fileType === 'image/png') {
+        return resizeSaveImage(context, formatFileId, buffer, fileType).then((resizedImage)=>insertFile(context, {
+                ...resizedImage,
+                _key: formatFileId,
+                added: now,
+                description,
+                modified: now,
+                name: updatedName,
+                userId: sessionId
+            }));
+    }
+    return insertFile(context, {
+        ...formattedFile,
+        added: now,
+        modified: now,
+        userId: sessionId
+    });
+};
+export const addFile = (context, file)=>{
+    const action = 'addFile';
+    const { base64, url } = file;
+    if (!!url) {
+        return httpGet(url).then((body)=>uploadFile(context, file, Buffer.from(body, 'binary'))).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                label: ErrorTypes.FILE_REQUEST
+            }, error, context));
+    } else if (!!base64) {
+        const buffer = Buffer.from(base64);
+        return uploadFile(context, file, buffer);
+    }
+    return Promise.reject(new Error(ErrorTypes.FILE_REQUIRED));
+};
+export const parseGiphyItem = (gifImage)=>{
+    const { id, images: { original: { url = '' } = {}, fixed_height_small: { url: thumb = '' } = {} } = {} } = gifImage;
+    if (!id || !url) {
+        return null;
+    }
+    return {
+        id,
+        thumb,
+        type: 'giphy',
+        url
+    };
+};
+export const getGiphyTrends = (limit = 30)=>{
+    const gifUrl = `${GIPHY_URL}/trending?api_key=${Config.get('giphy.key')}&limit=${limit}`;
+    return httpGet(gifUrl).then((res)=>res.json()).then((json)=>json?.data?.map(parseGiphyItem).filter((item)=>!!item));
+};
+export const getGiphySearch = (query, limit = 30)=>{
+    const formatQuery = encodeURI(query);
+    const gifUrl = `${GIPHY_URL}/search?q=${formatQuery}&api_key=${Config.get('giphy.key')}&limit=${limit}`;
+    return httpGet(gifUrl).then((res)=>res.json()).then((json)=>json?.data?.map(parseGiphyItem).filter((item)=>!!item));
+};
+export const getYouTubeTrends = (limit = 30)=>{
+    // const action = 'getYouTubeTrends';
+    const youtube = getYouTube();
+    return new Promise((resolve, reject)=>{
+        youtube.videos.list({
+            chart: 'mostPopular',
+            maxResults: limit,
+            part: [
+                'snippet'
+            ],
+            regionCode: 'US'
+        }, (error, data)=>{
+            if (error) {
+                console.error(error);
+                reject(new Error(ErrorTypes.YOUTUBE_ERROR));
+            } else if (data) {
+                const list = data.items.map((item)=>({
+                        id: item.id,
+                        thumb: item.snippet.thumbnails.high.url,
+                        type: 'youtube',
+                        url: `http://www.youtube.com/embed/${item.id}`
+                    }));
+                resolve(list);
+            }
+        });
+    });
+};
+export const getYouTubeSearch = (query, limit = 30)=>{
+    // const action = 'getYouTubeSearch';
+    const youtube = getYouTube();
+    return new Promise((resolve, reject)=>{
+        youtube.search.list({
+            maxResults: limit,
+            part: [
+                'snippet'
+            ],
+            q: query,
+            regionCode: 'US'
+        }, (error, data)=>{
+            if (error) {
+                console.error(error);
+                reject(new Error(ErrorTypes.YOUTUBE_ERROR));
+            } else if (data) {
+                const { items } = data;
+                const list = items.map((item)=>({
+                        id: item.id,
+                        thumb: item.snippet.thumbnails.high.url,
+                        type: 'youtube',
+                        url: `http://www.youtube.com/embed/${item.id}`
+                    }));
+                resolve(list);
+            }
+        });
+    });
+};
+export const getPathUserFiles = (userId, filename)=>`users/${userId}/files/${filename}`;
+export const linkFiles = (context, postDocId, files)=>Promise.all(files.map((file)=>upsertFile(context, file).then((file)=>createPostEdge(context, postDocId, file.id, 'isPosted', {
+                type: file.fileType
+            }))));
+export const updateFiles = (context, postDocId, files)=>{
+    const action = 'updateFiles';
+    const { databaseName } = context;
+    const edgeCollection = useDb(databaseName).collection('isPosted');
+    return edgeCollection.inEdges(postDocId, {}).then((edges)=>{
+        if (edges.length) {
+            return Promise.all(edges.map((edge)=>{
+                const { _key: edgeKey } = edge;
+                const aqlQry = aql`REMOVE {_key:${edgeKey}} IN isPosted`;
+                return useDb(databaseName).query(aqlQry).catch((error)=>{
+                    throw error;
+                });
+            })).then(()=>{
+                if (files.length) {
+                    return linkFiles(context, postDocId, files).then(()=>files);
+                }
+                return [];
+            });
+        } else if (files.length) {
+            return linkFiles(context, postDocId, files).then(()=>files);
+        }
+        return files;
+    }).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+export const encodeBase64 = (buffer)=>Buffer.from(buffer).toString('base64');
+export const decodeBase64 = (dataString)=>{
+    // const action = 'decodeBase64';
+    const getData = (str)=>str.match(/^data:([A-Za-z-+/]+);base64,(.+)$/) || [];
+    let matches = getData(dataString);
+    if (matches.length !== 3) {
+        matches = getData(decodeURIComponent(dataString));
+        if (matches.length !== 3) {
+            throw Error(ErrorTypes.INVALID_INPUT);
+        }
+    }
+    return {
+        data: Buffer.from(matches[2], 'base64'),
+        type: matches[1]
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/files.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 {get as httpGet} from '@nlabs/rip-hunter';\nimport {createHash} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\nimport {google} from 'googleapis';\n\nimport {parseFile} from '../adapters/fileAdapter.js';\nimport {Config} from '../config.js';\nimport {ApiContext} from '../types/auth.types.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {FileType} from '../types/files.types.js';\nimport {ImageType} from '../types/images.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\nimport {useDb} from '../utils/arangodbUtils.js';\nimport {resizeSaveImage} from './images.js';\nimport {createPostEdge} from './posts.js';\n\nimport type {EdgeCollection} from 'arangojs/collections';\n\nconst eventCategory: string = 'files';\n\nexport const GIPHY_URL: string = 'http://api.giphy.com/v1/gifs';\n\nexport const getYouTube = () => google.youtube({auth: Config.get('google.key'), version: 'v3'});\n\nexport const insertFile = (context: ApiContext, file: FileType) => {\n  const action = 'insertFile';\n  const {databaseName} = context;\n  const formattedFile = parseFile(file);\n  const aqlQry: AqlQuery = aql`INSERT ${formattedFile} IN files RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const upsertFile = (context: ApiContext, file: FileType): Promise<FileType> => {\n  const action = 'upsertFile';\n  const {databaseName} = context;\n  const formattedFile = parseFile(file);\n  const {fileId} = formattedFile;\n  const insert: any = {\n    ...formattedFile,\n    _key: fileId,\n    added: Date.now(),\n    modified: Date.now()\n  };\n  const update: any = {\n    ...formattedFile,\n    _key: fileId,\n    modified: Date.now()\n  };\n\n  const aqlQry: AqlQuery = aql`UPSERT {_key: ${fileId}}\n    INSERT ${insert}\n    UPDATE ${update}\n    IN files RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((updatedFile: FileType) => updatedFile)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const uploadFile = (context, file: FileType, buffer: Buffer) => {\n  const {session: {userId: sessionId}} = context;\n  const formattedFile = parseFile(file);\n  const {\n    description,\n    fileId,\n    fileType,\n    name,\n    url\n  } = formattedFile;\n  const now = Date.now();\n  const formatFileId: string = fileId || createHash(`file-${sessionId}`);\n  let updatedName = name;\n\n  if(!updatedName && !!url) {\n    updatedName = url.substring(url.lastIndexOf('/') + 1);\n  }\n\n  if(fileType === 'image/jpeg' || fileType === 'image/png') {\n    return resizeSaveImage(context, formatFileId, buffer, fileType)\n      .then((resizedImage: FileType) => insertFile(context, {\n        ...resizedImage,\n        _key: formatFileId,\n        added: now,\n        description,\n        modified: now,\n        name: updatedName,\n        userId: sessionId\n      }));\n  }\n\n  return insertFile(context, {\n    ...formattedFile,\n    added: now,\n    modified: now,\n    userId: sessionId\n  });\n};\n\nexport const addFile = (context: ApiContext, file: FileType): Promise<FileType> => {\n  const action = 'addFile';\n  const {base64, url} = file;\n\n  if(!!url) {\n    return httpGet(url)\n      .then((body) => uploadFile(context, file, Buffer.from(body, 'binary')))\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.FILE_REQUEST\n      }, error, context));\n  } else if(!!base64) {\n    const buffer: Buffer = Buffer.from(base64);\n    return uploadFile(context, file, buffer);\n  }\n\n  return Promise.reject(new Error(ErrorTypes.FILE_REQUIRED));\n};\n\nexport const parseGiphyItem = (gifImage: any): ImageType => {\n  const {\n    id,\n    images: {\n      original: {url = ''} = {},\n      fixed_height_small: {url: thumb = ''} = {}\n    } = {}\n  } = gifImage;\n\n  if(!id || !url) {\n    return null;\n  }\n\n  return {\n    id,\n    thumb,\n    type: 'giphy',\n    url\n  };\n};\n\nexport const getGiphyTrends = (limit: number = 30): Promise<ImageType[]> => {\n  const gifUrl = `${GIPHY_URL}/trending?api_key=${Config.get('giphy.key')}&limit=${limit}`;\n\n  return httpGet(gifUrl)\n    .then((res: Response) => res.json())\n    .then((json: any) => json?.data?.map(parseGiphyItem).filter((item) => !!item));\n};\n\nexport const getGiphySearch = (query: string, limit: number = 30): Promise<ImageType[]> => {\n  const formatQuery = encodeURI(query);\n  const gifUrl = `${GIPHY_URL}/search?q=${formatQuery}&api_key=${Config.get('giphy.key')}&limit=${limit}`;\n\n  return httpGet(gifUrl)\n    .then((res: Response) => res.json())\n    .then((json: any) => json?.data?.map(parseGiphyItem).filter((item) => !!item));\n};\n\nexport const getYouTubeTrends = (limit: number = 30): Promise<any[]> => {\n  // const action = 'getYouTubeTrends';\n  const youtube = getYouTube();\n\n  return new Promise((resolve, reject) => {\n    youtube.videos.list({\n      chart: 'mostPopular',\n      maxResults: limit,\n      part: ['snippet'],\n      regionCode: 'US'\n    }, (error: Error, data: any) => {\n      if(error) {\n        console.error(error);\n        reject(new Error(ErrorTypes.YOUTUBE_ERROR));\n      } else if(data) {\n        const list = data.items.map((item) => ({\n          id: item.id,\n          thumb: item.snippet.thumbnails.high.url,\n          type: 'youtube',\n          url: `http://www.youtube.com/embed/${item.id}`\n        }));\n\n        resolve(list);\n      }\n    });\n  });\n};\n\nexport const getYouTubeSearch = (query: string, limit: number = 30): Promise<any[]> => {\n  // const action = 'getYouTubeSearch';\n  const youtube = getYouTube();\n\n  return new Promise((resolve, reject) => {\n    youtube.search.list({\n      maxResults: limit,\n      part: ['snippet'],\n      q: query,\n      regionCode: 'US'\n    }, (error: Error, data: any) => {\n      if(error) {\n        console.error(error);\n        reject(new Error(ErrorTypes.YOUTUBE_ERROR));\n      } else if(data) {\n        const {items} = data;\n        const list = items.map((item) => ({\n          id: item.id,\n          thumb: item.snippet.thumbnails.high.url,\n          type: 'youtube',\n          url: `http://www.youtube.com/embed/${item.id}`\n        }));\n\n        resolve(list);\n      }\n    });\n  });\n};\n\nexport const getPathUserFiles = (userId: string, filename: string): string => `users/${userId}/files/${filename}`;\n\nexport const linkFiles = (context: ApiContext, postDocId: string, files: FileType[]): Promise<any> =>\n  Promise.all(\n    files.map((file: FileType) => upsertFile(context, file)\n      .then((file: FileType) => createPostEdge(context, postDocId, file.id, 'isPosted', {type: file.fileType})))\n  );\n\nexport const updateFiles = (context: ApiContext, postDocId: string, files: FileType[]): Promise<any> => {\n  const action = 'updateFiles';\n  const {databaseName} = context;\n  const edgeCollection: EdgeCollection = useDb(databaseName).collection('isPosted');\n\n  return edgeCollection.inEdges(postDocId, {})\n    .then((edges: any) => {\n      if(edges.length) {\n        return Promise.all(\n          edges.map((edge) => {\n            const {_key: edgeKey} = edge;\n            const aqlQry: AqlQuery = aql`REMOVE {_key:${edgeKey}} IN isPosted`;\n\n            return useDb(databaseName).query(aqlQry)\n              .catch((error: Error) => {\n                throw error;\n              });\n          }))\n          .then(() => {\n            if(files.length) {\n              return linkFiles(context, postDocId, files).then(() => files);\n            }\n\n            return [];\n          });\n      } else if(files.length) {\n        return linkFiles(context, postDocId, files)\n          .then(() => files);\n      }\n\n      return files;\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const encodeBase64 = (buffer: Buffer): string => Buffer.from(buffer).toString('base64');\n\nexport const decodeBase64 = (dataString: string): any => {\n  // const action = 'decodeBase64';\n  const getData = (str: string) => str.match(/^data:([A-Za-z-+/]+);base64,(.+)$/) || [];\n  let matches = getData(dataString);\n\n  if(matches.length !== 3) {\n    matches = getData(decodeURIComponent(dataString));\n\n    if(matches.length !== 3) {\n      throw Error(ErrorTypes.INVALID_INPUT);\n    }\n  }\n\n  return {\n    data: Buffer.from(matches[2], 'base64'),\n    type: matches[1]\n  };\n};\n"],"names":["get","httpGet","createHash","aql","google","parseFile","Config","ErrorTypes","logError","useDb","resizeSaveImage","createPostEdge","eventCategory","GIPHY_URL","getYouTube","youtube","auth","version","insertFile","context","file","action","databaseName","formattedFile","aqlQry","query","then","cursor","next","catch","error","category","label","DATABASE_ERROR","upsertFile","fileId","insert","_key","added","Date","now","modified","update","updatedFile","uploadFile","buffer","session","userId","sessionId","description","fileType","name","url","formatFileId","updatedName","substring","lastIndexOf","resizedImage","addFile","base64","body","Buffer","from","FILE_REQUEST","Promise","reject","Error","FILE_REQUIRED","parseGiphyItem","gifImage","id","images","original","fixed_height_small","thumb","type","getGiphyTrends","limit","gifUrl","res","json","data","map","filter","item","getGiphySearch","formatQuery","encodeURI","getYouTubeTrends","resolve","videos","list","chart","maxResults","part","regionCode","console","YOUTUBE_ERROR","items","snippet","thumbnails","high","getYouTubeSearch","search","q","getPathUserFiles","filename","linkFiles","postDocId","files","all","updateFiles","edgeCollection","collection","inEdges","edges","length","edge","edgeKey","encodeBase64","toString","decodeBase64","dataString","getData","str","match","matches","decodeURIComponent","INVALID_INPUT"],"mappings":"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"}

package/lib/actions/groups.d.ts

@@ -11,3 +11,4 @@ export declare const updateGroup: (context: ApiContext, item: GroupType) => Prom
 export declare const deleteGroup: (context: ApiContext, itemId: string) => Promise<GroupType>;
 export declare const getGroupsByReaction: (context: ApiContext, reaction: string) => Promise<GroupType[]>;
 export declare const isGrouped: (context: ApiContext, userId: string, groupId: string) => Promise<GroupUser>;
+//# sourceMappingURL=groups.d.ts.map

package/lib/actions/groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"groups.d.ts","sourceRoot":"","sources":["../../src/actions/groups.ts"],"names":[],"mappings":"AAOA,OAAO,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAElD,OAAO,EAAC,aAAa,EAAE,SAAS,EAAE,SAAS,EAAC,MAAM,0BAA0B,CAAC;AAa7E,eAAO,MAAM,YAAY,GAAI,SAAS,UAAU,EAAE,MAAM,MAAM,EAAE,IAAI,MAAM,KAAG,OAAO,CAAC,SAAS,EAAE,CAwB/F,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,SAAS,UAAU,EAAE,MAAM,MAAM,EAAE,IAAI,MAAM,KAAG,OAAO,CAAC,SAAS,EAAE,CAwBrG,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAC7B,SAAS,UAAU,EACnB,MAAM,MAAM,EAAE,EACd,MAAM,MAAM,EACZ,IAAI,MAAM,KACT,OAAO,CAAC,SAAS,EAAE,CA2CrB,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,SAAS,UAAU,EAAE,QAAQ,MAAM,KAAG,OAAO,CAAC,SAAS,CAsB/E,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,SAAS,UAAU,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,SAAS,CAiBvF,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,SAAS,UAAU,EACnB,QAAQ,MAAM,EACd,SAAS,MAAM,KACd,OAAO,CAAC,aAAa,CAwBvB,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,SAAS,UAAU,EAAE,MAAM,SAAS,KAAG,OAAO,CAAC,SAAS,CAqChF,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,SAAS,UAAU,EAAE,MAAM,SAAS,KAAG,OAAO,CAAC,SAAS,CAgCnF,CAAC;AAEF,eAAO,MAAM,WAAW,GAAI,SAAS,UAAU,EAAE,QAAQ,MAAM,KAAG,OAAO,CAAC,SAAS,CAiBlF,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,SAAS,UAAU,EAAE,UAAU,MAAM,KAAG,OAAO,CAAC,SAAS,EAAE,CAmB9F,CAAC;AAEF,eAAO,MAAM,SAAS,GAAI,SAAS,UAAU,EAAE,QAAQ,MAAM,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,SAAS,CA4BjG,CAAC"}

package/lib/actions/groups.js

@@ -0,0 +1,267 @@
+/**
+ * Copyright (c) 2019-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { aql } from 'arangojs';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+import { getLimit, useDb } from '../utils/arangodbUtils.js';
+import { extractTags, updateTagsInItem } from './tags.js';
+import { flatten } from '@nlabs/utils/arrays/flatten';
+import { uniqBy } from '@nlabs/utils/arrays/uniq';
+import { createHash, parseArangoId, parseChar, parseId } from '@nlabs/utils/parsers/strings';
+const eventCategory = 'groups';
+export const getGroupList = (context, from, to)=>{
+    const action = 'getListByApp';
+    const { databaseName } = context;
+    const limit = getLimit(from, to);
+    const aqlQry = `FOR g in groups
+      LET users = (
+        FOR u, l IN OUTBOUND g._id hasConnection
+        RETURN MERGE (u, {type:l.type})
+      )
+      ${limit.aql}
+      SORT g.added
+      RETURN DISTINCT MERGE(g, {users:users})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null);
+        return [];
+    });
+};
+export const getGroupListByUser = (context, from, to)=>{
+    const action = 'getGroupListByUser';
+    const { databaseName, session: { userId: sessionId } = {} } = context;
+    const limit = getLimit(from, to);
+    const aqlQry = `FOR g, e IN INBOUND "${`users/${sessionId}`}" hasConnection
+      LET users = (
+        FOR u, l IN OUTBOUND g._id hasConnection
+        RETURN MERGE (u, {type:l.type})
+      )
+      ${limit.aql}
+      SORT g.added
+      RETURN DISTINCT MERGE(g, {users:users})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null);
+        return [];
+    });
+};
+export const getGroupListByTags = (context, tags, from, to)=>{
+    const action = 'getListByTags';
+    const { databaseName } = context;
+    return Promise.all(tags.map((tagName)=>{
+        const formatTagName = parseId(tagName);
+        const limit = getLimit(from, to);
+        const aqlQry = `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(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+            logError({
+                action,
+                category: eventCategory,
+                label: ErrorTypes.DATABASE_ERROR
+            }, error, context).then(()=>null);
+            return [];
+        });
+    })).then((results)=>uniqBy(flatten(results), (item)=>item._key)).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+export const getGroup = (context, itemId)=>{
+    const action = 'getItem';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const formatItemId = parseId(itemId);
+    const aqlQry = aql`FOR g, e IN INBOUND ${`users/${sessionId}`} hasConnection
+      FILTER g._key == ${formatItemId}
+      LET users = (
+        FOR u, l IN OUTBOUND g._id hasConnection
+        RETURN MERGE (u, {type:l.type})
+      )
+      LIMIT 1
+      RETURN DISTINCT MERGE(g, {users:users})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((group)=>group).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+export const getGroupDetails = (context, groupId)=>{
+    const action = 'getDetails';
+    const { databaseName } = context;
+    const formatGroupId = parseId(groupId);
+    const aqlQry = aql`FOR g IN groups
+      FILTER g._key == ${formatGroupId}
+      LIMIT 1
+      RETURN g`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((group)=>group).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+export const createGroupEdge = (context, userId, groupId)=>{
+    const action = 'createGroupEdge';
+    const { databaseName } = context;
+    const formatUserId = parseArangoId(userId);
+    const formatGroupId = parseArangoId(groupId);
+    const now = Date.now();
+    const edgeCollection = useDb(databaseName).collection('hasConnection');
+    const edgeId = createHash(`group-${formatUserId}-${formatGroupId}`);
+    const edge = {
+        _from: formatUserId,
+        _key: edgeId,
+        _to: formatGroupId,
+        added: now,
+        type: 'groups'
+    };
+    return edgeCollection.save(edge, {
+        returnNew: true
+    }).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, {
+            session: {
+                userId: formatUserId
+            }
+        }).then(()=>null));
+};
+export const addGroup = (context, item)=>{
+    const action = 'add';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const now = Date.now();
+    const { description = '', name = 'Untitled', type } = item;
+    const id = createHash(`group-${sessionId}`);
+    const formatDesc = description.substr(0, 640);
+    const formatType = parseChar(type, 16) || 'private';
+    const insert = {
+        _key: id,
+        added: now,
+        description: formatDesc,
+        modified: now,
+        name,
+        type: formatType
+    };
+    const aqlQry = aql`INSERT ${insert} IN groups RETURN NEW`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((group)=>{
+        // Update linked tags
+        const { _id: groupDocId } = group;
+        const tags = extractTags(formatDesc);
+        return updateTagsInItem(context, {
+            itemDocId: groupDocId,
+            tags
+        }).then(()=>createGroupEdge(context, sessionId, groupDocId).then(()=>group));
+    }).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+export const updateGroup = (context, item)=>{
+    const action = 'update';
+    const { databaseName } = context;
+    const { description = '', id, name = 'Untitled' } = item;
+    const itemId = parseId(id);
+    const now = Date.now();
+    const formatDesc = description.substr(0, 640);
+    const update = {
+        description: formatDesc,
+        modified: now,
+        name
+    };
+    const aqlQry = aql`UPDATE ${itemId} WITH ${update} IN groups RETURN NEW`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((group)=>{
+        const { _id: groupDocId } = group;
+        // Update linked tags
+        const tags = extractTags(description);
+        return updateTagsInItem(context, {
+            itemDocId: groupDocId,
+            tags
+        }).then(()=>group);
+    }).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+export const deleteGroup = (context, itemId)=>{
+    const action = 'delete';
+    const { databaseName } = context;
+    const formatItemId = parseId(itemId);
+    const aqlQry = aql`FOR g IN groups
+      FILTER g._key == ${formatItemId}
+      REMOVE g IN groups
+      RETURN OLD`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((group)=>group).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+export const getGroupsByReaction = (context, reaction)=>{
+    const action = 'getGroupsByReaction';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const formatReaction = parseChar(reaction, 32);
+    const userDocId = `users/${sessionId}`;
+    // Query
+    const aqlQry = 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(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, context).then(()=>null));
+};
+export const isGrouped = (context, userId, groupId)=>{
+    const action = 'isGrouped';
+    const { databaseName } = context;
+    const formatUserId = parseId(userId);
+    const formatGroupId = parseId(groupId);
+    const aqlQry = aql`FOR g IN groups
+    FILTER g._key == ${formatGroupId}
+    FOR u IN INBOUND g._id hasConnection
+    FILTER u._key == ${formatUserId}
+    LIMIT 1
+    RETURN u`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).then((results = [])=>{
+        const isValid = !!results.length;
+        return {
+            groupId,
+            isValid,
+            userId
+        };
+    }).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            label: ErrorTypes.DATABASE_ERROR
+        }, error, {
+            session: {
+                userId
+            }
+        }).then(()=>null));
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/groups.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 {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\n\nimport {ApiContext} from '../types/auth.types.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {GroupEdgeType, GroupType, GroupUser} from '../types/groups.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\nimport {getLimit, useDb} from '../utils/arangodbUtils.js';\nimport {extractTags, updateTagsInItem} from './tags.js';\n\nimport {flatten} from '@nlabs/utils/arrays/flatten';\nimport {uniqBy} from '@nlabs/utils/arrays/uniq';\nimport {createHash, parseArangoId, parseChar, parseId} from '@nlabs/utils/parsers/strings';\nimport type {EdgeCollection} from 'arangojs/collections';\nimport type {ArangoDbLimit} from '../types/arangodb.types.js';\n\nconst eventCategory: string = 'groups';\n\nexport const getGroupList = (context: ApiContext, from: number, to: number): Promise<GroupType[]> => {\n  const action: string = 'getListByApp';\n  const {databaseName} = context;\n  const limit: ArangoDbLimit = getLimit(from, to);\n  const aqlQry: string = `FOR g in groups\n      LET users = (\n        FOR u, l IN OUTBOUND g._id hasConnection\n        RETURN MERGE (u, {type:l.type})\n      )\n      ${limit.aql}\n      SORT g.added\n      RETURN DISTINCT MERGE(g, {users:users})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context).then(() => null);\n\n      return [];\n    });\n};\n\nexport const getGroupListByUser = (context: ApiContext, from: number, to: number): Promise<GroupType[]> => {\n  const action: string = 'getGroupListByUser';\n  const {databaseName, session: {userId: sessionId} = {}} = context;\n  const limit: ArangoDbLimit = getLimit(from, to);\n  const aqlQry: string = `FOR g, e IN INBOUND \"${`users/${sessionId}`}\" hasConnection\n      LET users = (\n        FOR u, l IN OUTBOUND g._id hasConnection\n        RETURN MERGE (u, {type:l.type})\n      )\n      ${limit.aql}\n      SORT g.added\n      RETURN DISTINCT MERGE(g, {users:users})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        label: ErrorTypes.DATABASE_ERROR\n      }, error, context).then(() => null);\n\n      return [];\n    });\n};\n\nexport const getGroupListByTags = (\n  context: ApiContext,\n  tags: string[],\n  from: number,\n  to: number\n): Promise<GroupType[]> => {\n  const action: string = 'getListByTags';\n  const {databaseName} = context;\n\n  return Promise.all(\n    tags.map((tagName: string) => {\n      const formatTagName: string = parseId(tagName);\n      const limit: ArangoDbLimit = getLimit(from, to);\n      const aqlQry: string = `FOR p, e IN OUTBOUND \"${`tags/${formatTagName}`}\" isTagged\n          FOR u IN users\n          LET likes = (\n            FOR post, like IN INBOUND p._id likes\n            FILTER like.value == 'like'\n            RETURN like\n          )\n          LET dislikes = (\n            FOR post, like IN INBOUND p._id likes\n            FILTER like.value == 'dislike'\n            RETURN like\n          )\n          FILTER e.type == 'post' && p.userId == u._key\n          ${limit.aql}\n          SORT p.added\n          RETURN DISTINCT MERGE(p, {user:u, likes:LENGTH(likes), dislikes:LENGTH(dislikes)})`;\n\n      return useDb(databaseName).query(aqlQry).then((cursor) => cursor.all())\n        .catch((error: Error) => {\n          logError({\n            action,\n            category: eventCategory,\n            label: ErrorTypes.DATABASE_ERROR\n          }, error, context).then(() => null);\n\n          return [];\n        });\n    })\n  )\n    .then((results) => uniqBy(flatten(results), (item: any) => item._key))\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const getGroup = (context: ApiContext, itemId: string): Promise<GroupType> => {\n  const action: string = 'getItem';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const formatItemId: string = parseId(itemId);\n\n  const aqlQry: AqlQuery = aql`FOR g, e IN INBOUND ${`users/${sessionId}`} hasConnection\n      FILTER g._key == ${formatItemId}\n      LET users = (\n        FOR u, l IN OUTBOUND g._id hasConnection\n        RETURN MERGE (u, {type:l.type})\n      )\n      LIMIT 1\n      RETURN DISTINCT MERGE(g, {users:users})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((group: GroupType) => group)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const getGroupDetails = (context: ApiContext, groupId: string): Promise<GroupType> => {\n  const action: string = 'getDetails';\n  const {databaseName} = context;\n  const formatGroupId: string = parseId(groupId);\n  const aqlQry: AqlQuery = aql`FOR g IN groups\n      FILTER g._key == ${formatGroupId}\n      LIMIT 1\n      RETURN g`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((group: GroupType) => group)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const createGroupEdge = (\n  context: ApiContext,\n  userId: string,\n  groupId: string\n): Promise<GroupEdgeType> => {\n  const action: string = 'createGroupEdge';\n  const {databaseName} = context;\n  const formatUserId: string = parseArangoId(userId);\n  const formatGroupId: string = parseArangoId(groupId);\n\n  const now: number = Date.now();\n  const edgeCollection: EdgeCollection = useDb(databaseName).collection('hasConnection');\n  const edgeId: string = createHash(`group-${formatUserId}-${formatGroupId}`);\n\n  const edge: any = {\n    _from: formatUserId,\n    _key: edgeId,\n    _to: formatGroupId,\n    added: now,\n    type: 'groups'\n  };\n\n  return edgeCollection.save(edge, {returnNew: true})\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, {session: {userId: formatUserId}}).then(() => null));\n};\n\nexport const addGroup = (context: ApiContext, item: GroupType): Promise<GroupType> => {\n  const action: string = 'add';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const now: number = Date.now();\n  const {\n    description = '',\n    name = 'Untitled',\n    type\n  }: GroupType = item;\n  const id: string = createHash(`group-${sessionId}`);\n  const formatDesc: string = description.substr(0, 640);\n  const formatType: string = parseChar(type, 16) || 'private';\n  const insert: GroupType = {\n    _key: id,\n    added: now,\n    description: formatDesc,\n    modified: now,\n    name,\n    type: formatType\n  };\n  const aqlQry: AqlQuery = aql`INSERT ${insert} IN groups RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((group: GroupType) => {\n      // Update linked tags\n      const {_id: groupDocId}: GroupType = group;\n      const tags = extractTags(formatDesc);\n\n      return updateTagsInItem(context, {itemDocId: groupDocId, tags})\n        .then(() => createGroupEdge(context, sessionId, groupDocId).then(() => group));\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const updateGroup = (context: ApiContext, item: GroupType): Promise<GroupType> => {\n  const action: string = 'update';\n  const {databaseName} = context;\n  const {\n    description = '',\n    id,\n    name = 'Untitled'\n  }: GroupType = item;\n  const itemId: string = parseId(id);\n  const now: number = Date.now();\n  const formatDesc: string = description.substr(0, 640);\n  const update: any = {\n    description: formatDesc,\n    modified: now,\n    name\n  };\n  const aqlQry: AqlQuery = aql`UPDATE ${itemId} WITH ${update} IN groups RETURN NEW`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((group: GroupType) => {\n      const {_id: groupDocId} = group;\n\n      // Update linked tags\n      const tags = extractTags(description);\n      return updateTagsInItem(context, {itemDocId: groupDocId, tags}).then(() => group);\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const deleteGroup = (context: ApiContext, itemId: string): Promise<GroupType> => {\n  const action: string = 'delete';\n  const {databaseName} = context;\n  const formatItemId: string = parseId(itemId);\n  const aqlQry: AqlQuery = aql`FOR g IN groups\n      FILTER g._key == ${formatItemId}\n      REMOVE g IN groups\n      RETURN OLD`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then((group: GroupType) => group)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const getGroupsByReaction = (context: ApiContext, reaction: string): Promise<GroupType[]> => {\n  const action: string = 'getGroupsByReaction';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const formatReaction: string = parseChar(reaction, 32);\n  const userDocId: string = `users/${sessionId}`;\n\n  // Query\n  const aqlQry: AqlQuery = aql`FOR u, r IN OUTBOUND ${userDocId} hasReaction\n      FILTER r.value == ${formatReaction}\n      COLLECT reactionName = r.value INTO reactionItems\n      RETURN {value: reactionName, count: LENGTH(reactionItems[*].r.value)}`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, context).then(() => null));\n};\n\nexport const isGrouped = (context: ApiContext, userId: string, groupId: string): Promise<GroupUser> => {\n  const action: string = 'isGrouped';\n  const {databaseName} = context;\n  const formatUserId: string = parseId(userId);\n  const formatGroupId: string = parseId(groupId);\n  const aqlQry: AqlQuery = aql`FOR g IN groups\n    FILTER g._key == ${formatGroupId}\n    FOR u IN INBOUND g._id hasConnection\n    FILTER u._key == ${formatUserId}\n    LIMIT 1\n    RETURN u`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all())\n    .then((results = []) => {\n      const isValid = !!results.length;\n\n      return {\n        groupId,\n        isValid,\n        userId\n      };\n    })\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      label: ErrorTypes.DATABASE_ERROR\n    }, error, {session: {userId}}).then(() => null));\n};\n"],"names":["aql","ErrorTypes","logError","getLimit","useDb","extractTags","updateTagsInItem","flatten","uniqBy","createHash","parseArangoId","parseChar","parseId","eventCategory","getGroupList","context","from","to","action","databaseName","limit","aqlQry","query","then","cursor","all","catch","error","category","label","DATABASE_ERROR","getGroupListByUser","session","userId","sessionId","getGroupListByTags","tags","Promise","map","tagName","formatTagName","results","item","_key","getGroup","itemId","formatItemId","next","group","getGroupDetails","groupId","formatGroupId","createGroupEdge","formatUserId","now","Date","edgeCollection","collection","edgeId","edge","_from","_to","added","type","save","returnNew","addGroup","description","name","id","formatDesc","substr","formatType","insert","modified","_id","groupDocId","itemDocId","updateGroup","update","deleteGroup","getGroupsByReaction","reaction","formatReaction","userDocId","isGrouped","isValid","length"],"mappings":"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"}

package/lib/actions/images.d.ts

@@ -31,3 +31,4 @@ export declare const addImage: (context: ApiContext, image: ImageType, s3Options
 export declare const addImageEdge: (context: ApiContext, imageEdge: ImageEdgeType) => Promise<object>;
 export declare const updateImage: (context: ApiContext, image: ImageType, s3Options?: PutObjectCommandInput) => Promise<ImageType>;
 export declare const deleteImage: (context: ApiContext, imageId: string) => Promise<ImageType>;
+//# sourceMappingURL=images.d.ts.map

package/lib/actions/images.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"images.d.ts","sourceRoot":"","sources":["../../src/actions/images.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAA4B,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AAiBpF,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,wBAAwB,CAAC;AACxD,OAAO,KAAK,EAAqB,aAAa,EAAC,MAAM,4BAA4B,CAAC;AAClF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAEvD,OAAO,KAAK,EAAC,aAAa,EAAqB,YAAY,EAAE,SAAS,EAAE,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAUtH,eAAO,MAAM,iBAAiB,GAAI,UAAS,YAAiB;WAQ3B,aAAa;;CAG7C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,SAAQ,MAAM,EAAO,QAsCtB,CAAC;AAEjC,eAAO,MAAM,eAAe,GAC1B,SAAS,UAAU,EACnB,QAAQ,MAAM,EACd,OAAM,MAAU,EAChB,KAAI,MAAW,KACd,OAAO,CAAC,SAAS,EAAE,CA6BrB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,SAAS,UAAU,EAAE,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CAiBvF,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,SAAS,UAAU,EACnB,QAAQ,MAAM,EACd,UAAS,YAAiB,KACzB,OAAO,CAAC,SAAS,EAAE,CAwBrB,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAC3B,SAAS,UAAU,EACnB,QAAQ;IAAC,OAAO,EAAE,WAAW,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAC,KAC1E,OAAO,CAAC,SAAS,EAAE,CAoFrB,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAC/B,SAAS,UAAU,EACnB,YAAW,MAAM,EAAO,EACxB,UAAU,YAAY,KACrB,OAAO,CAAC,SAAS,EAAE,CA8BrB,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,SAAS,UAAU,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,SAAS,CAiBhF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,EAAE,SAAS,MAAM,EAAE,WAAW,MAAM,EAAE,MAAK,MAAiB,KAAG,MAa9G,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,kEAQ5B,YAAY,KAAG,MAqBjB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,0EAS/B,YAAY,KAAG,OAAO,CAAC,MAAM,CAgC/B,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,SAAS,UAAU,EACnB,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,WAAU,MAAqB,EAAE,YAAY,qBAAqB,KACjE,OAAO,CAAC,SAAS,CAsLnB,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,SAAS,UAAU,EACnB,OAAO,SAAS,EAChB,YAAY,qBAAqB,KAChC,OAAO,CAAC,SAAS,CAkCnB,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,SAAS,UAAU,EAAE,WAAW,aAAa,KAAG,OAAO,CAAC,MAAM,CAwChG,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,SAAS,UAAU,EACnB,OAAO,SAAS,EAChB,YAAY,qBAAqB,KAChC,OAAO,CAAC,SAAS,CA8HnB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,SAAS,UAAU,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,SAAS,CA6CzF,CAAC"}