@nlabs/reaktor 0.10.5 → 0.10.6

package/lib/actions/videos.d.ts

@@ -23,3 +23,4 @@ export declare const addVideo: (context: ApiContext, video: VideoType, s3Options
 export declare const addVideoEdge: (context: ApiContext, videoEdge: VideoEdgeType) => Promise<object>;
 export declare const updateVideo: (context: ApiContext, video: VideoType, s3Options?: PutObjectCommandInput) => Promise<VideoType>;
 export declare const deleteVideo: (context: ApiContext, videoId: string) => Promise<VideoType>;
+//# sourceMappingURL=videos.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"videos.d.ts","sourceRoot":"","sources":["../../src/actions/videos.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAA4B,qBAAqB,EAAC,MAAM,oBAAoB,CAAC;AAYpF,OAAO,KAAK,EAAqB,aAAa,EAAC,MAAM,4BAA4B,CAAC;AAClF,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,KAAK,EAAC,aAAa,EAAE,YAAY,EAAE,SAAS,EAAE,YAAY,EAAC,MAAM,0BAA0B,CAAC;AAInG,eAAO,MAAM,iBAAiB,GAAI,UAAS,YAAiB;WAI3B,aAAa;;CAG7C,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,SAAQ,MAAM,EAAO,QA0BtB,CAAC;AAEjC,eAAO,MAAM,eAAe,GAC1B,SAAS,UAAU,EACnB,QAAQ,MAAM,EACd,OAAM,MAAU,EAChB,KAAI,MAAW,KACd,OAAO,CAAC,SAAS,EAAE,CAsBrB,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,SAAS,UAAU,EAAE,QAAQ,MAAM,KAAG,OAAO,CAAC,MAAM,CAcvF,CAAC;AAEF,eAAO,MAAM,eAAe,GAC1B,SAAS,UAAU,EACnB,QAAQ,MAAM,EACd,UAAS,YAAiB,KACzB,OAAO,CAAC,SAAS,EAAE,CAuBrB,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,SAAS,UAAU,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,SAAS,CAahF,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,QAAQ,MAAM,EAAE,SAAS,MAAM,EAAE,WAAW,MAAM,EAAE,MAAK,MAAiB,KAAG,MAgB9G,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,uDAO5B,YAAY,KAAG,MAkBjB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,gEAQ/B,GAAG,KAAG,OAAO,CAAC,MAAM,CAuBtB,CAAC;AAEF,eAAO,MAAM,SAAS,GACpB,SAAS,UAAU,EACnB,SAAS,MAAM,EACf,QAAQ,MAAM,EACd,WAAU,MAAoB,EAAE,YAAY,qBAAqB,KAChE,OAAO,CAAC,SAAS,CAmBnB,CAAC;AAEF,eAAO,MAAM,QAAQ,GACnB,SAAS,UAAU,EACnB,OAAO,SAAS,EAChB,YAAY,qBAAqB,KAChC,OAAO,CAAC,SAAS,CAmDnB,CAAC;AAEF,eAAO,MAAM,YAAY,GAAU,SAAS,UAAU,EAAE,WAAW,aAAa,KAAG,OAAO,CAAC,MAAM,CA+BhG,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,SAAS,UAAU,EACnB,OAAO,SAAS,EAChB,YAAY,qBAAqB,KAChC,OAAO,CAAC,SAAS,CA6HnB,CAAC;AAEF,eAAO,MAAM,WAAW,GAAU,SAAS,UAAU,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,SAAS,CAmCzF,CAAC"}

package/lib/actions/videos.js

@@ -0,0 +1,423 @@
+/**
+ * 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, parseArangoId, parseChar, parseId } from '@nlabs/utils/parsers/strings';
+import { aql } from 'arangojs';
+import { Config } from '../config.js';
+import { ErrorTypes } from '../types/error.types.js';
+import { logError } from '../utils/analyticsUtils.js';
+import { getDocId, getLimit, selectReactionCountByType, useDb } from '../utils/arangodbUtils.js';
+import { s3DeleteList, s3GetSignedUrl, s3Put } from './s3.js';
+const eventCategory = 'videos';
+export const parseVideoOptions = (options = {})=>{
+    const { from = 0, to = 30, type = 'default' } = options;
+    return {
+        limit: getLimit(from, to),
+        type: parseChar(type, 32)
+    };
+};
+export const getVideoOptional = (fields = [])=>fields.reduce((selects, field)=>{
+        if (field.includes('Count')) {
+            return selectReactionCountByType('videos', 'v', field, selects);
+        }
+        switch(field){
+            case 'reactions':
+                {
+                    selects.queries.push(`LET reactions = (FOR video, r IN INBOUND v._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 v._id isTagged RETURN t)`);
+                    selects.objects.push('tags:tags');
+                    return selects;
+                }
+            case 'users':
+                {
+                    selects.queries.push(`LET users = FIRST(FOR u IN users FILTER v.userId == u._key LIMIT 1 RETURN u)`);
+                    selects.objects.push('users:users');
+                    return selects;
+                }
+            default:
+                {
+                    return selects;
+                }
+        }
+    }, {
+        objects: [],
+        queries: []
+    });
+export const getVideosByUser = (context, userId, from = 0, to = 30)=>{
+    const action = 'getVideosByUser';
+    const { databaseName } = context;
+    const formatUserId = parseId(userId);
+    const limit = getLimit(from, to);
+    const aqlQry = `FOR v IN videos
+      FILTER v.userId == "${formatUserId}"
+      LET user = FIRST(FOR u IN users FILTER u._key == v.userId LIMIT 1 RETURN u)
+      ${limit.aql}
+      SORT v.added
+      RETURN MERGE(v, {user:user})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getVideoCountByItem = (context, itemId)=>{
+    const action = 'getVideoCountByItem';
+    const { databaseName } = context;
+    const formatItemId = parseArangoId(itemId);
+    const aqlQry = aql`FOR v IN hasVideo FILTER v._to == ${formatItemId} RETURN {count: COUNT(v)}`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then(({ count })=>count).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+export const getVideosByItem = async (context, itemId, options = {})=>{
+    const action = 'getVideosByItem';
+    const { databaseName, fields = [] } = context;
+    const formatItemId = parseArangoId(itemId);
+    const { limit } = parseVideoOptions(options);
+    const { objects: selectObjects, queries: selectQueries } = getVideoOptional(fields);
+    const aqlQry = `FOR v, l IN 1..1 OUTBOUND "${formatItemId}" hasVideo
+    FILTER NOT IS_NULL(v)
+    ${selectQueries.join('\n')}
+    SORT v.added
+    ${limit.aql}
+    RETURN MERGE(v, {${selectObjects.join(', ')}})`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.all()).catch((error)=>{
+        logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+        return [];
+    });
+};
+export const getVideo = (context, videoId)=>{
+    const action = 'getVideo';
+    const { databaseName } = context;
+    const formatVideoId = parseId(videoId);
+    const aqlQry = aql`FOR v IN videos FILTER v._key==${formatVideoId} LIMIT 1 RETURN v`;
+    return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context));
+};
+export const getPathUserVideos = (userId, videoId, videoType, dir = 'videos')=>{
+    let filename = videoId;
+    switch(videoType){
+        case 'video/webm':
+            filename = `${videoId}.webm`;
+            break;
+        case 'video/quicktime':
+            filename = `${videoId}.mov`;
+            break;
+        default:
+            filename = `${videoId}.mp4`;
+            break;
+    }
+    return `users/${userId}/${dir}/${filename}`;
+};
+export const getAppVideoUrl = ({ bucket, directory = 'videos', isThumb = false, type, typeId, videoId })=>{
+    if (!type) {
+        return '';
+    }
+    if (!videoId) {
+        return '';
+    }
+    const bucketName = bucket || Config.get('image.bucket') || 'dev.reaktor.io';
+    const videoName = `${videoId}.mp4`;
+    const videoUrl = Config.get('image.url') || `https://s3.amazonaws.com/${bucketName}`;
+    if (type === 'apps') {
+        return `${videoUrl}/${type}/${directory}/${videoName}`;
+    }
+    return `${videoUrl}/${type}/${typeId}/${directory}/${videoName}`;
+};
+export const getVideoUrl = async ({ bucket, imageDir = 'videos', videoDir = 'videos', videoId, type, typeId, urlType = 'public' })=>{
+    if (!videoId) {
+        return '';
+    }
+    const keyDir = videoDir || imageDir || 'videos';
+    const videoKey = `${type}/${typeId}/${keyDir}/${videoId}.mp4`;
+    switch(urlType){
+        case 'signed':
+            {
+                const defaultBucket = Config.get('image.bucket') || 'dev.reaktor.io';
+                return await s3GetSignedUrl({
+                    Bucket: bucket || defaultBucket,
+                    Expires: 900,
+                    Key: videoKey
+                });
+            }
+        case 'public':
+            {
+                return `https://box.${Config.get('app.url')}/${videoKey}`;
+            }
+        case 'dev':
+            {
+                return `https://s3.amazonaws.com/dev.${Config.get('app.url')}/${videoKey}`;
+            }
+        default:
+            {
+                return '';
+            }
+    }
+};
+export const saveVideo = async (context, videoId, buffer, fileType = 'video/mp4', s3Options)=>{
+    const { session: { userId: sessionId } } = context;
+    const videoObj = {
+        ACL: 'authenticated-read',
+        Body: buffer,
+        Bucket: null,
+        ContentType: fileType,
+        ...s3Options || {},
+        Key: getPathUserVideos(sessionId, videoId, fileType, 'videos')
+    };
+    await s3Put(videoObj);
+    return {
+        fileSize: buffer.length,
+        fileType,
+        videoId
+    };
+};
+export const addVideo = (context, video, s3Options)=>{
+    const action = 'addVideo';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { videoId, description, buffer, fileType, type = 'video', provider, externalId, externalUrl } = video;
+    const now = Date.now();
+    if (type === 'external') {
+        const insert = {
+            _key: videoId,
+            added: now,
+            description,
+            externalId,
+            externalUrl,
+            provider,
+            type,
+            userId: sessionId
+        };
+        const aqlQry = aql`INSERT ${insert} IN videos RETURN NEW`;
+        return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+    }
+    return saveVideo(context, videoId, buffer, fileType, s3Options).then((saved)=>{
+        const insert = {
+            ...saved,
+            _key: videoId,
+            added: now,
+            description,
+            fileType,
+            modified: now,
+            type,
+            userId: sessionId
+        };
+        const aqlQry = aql`INSERT ${insert} IN videos RETURN NEW`;
+        return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+    });
+};
+export const addVideoEdge = async (context, videoEdge)=>{
+    const action = 'addVideoEdge';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { videoId, itemId, itemType } = videoEdge;
+    const now = Date.now();
+    const edgeId = createHash(`hasVideo-${videoId}-${itemId}-${sessionId}`);
+    const formatItemType = parseChar(itemType).toLowerCase();
+    const formatItemId = parseId(itemId);
+    const itemDocId = getDocId(formatItemType, {
+        _key: formatItemId
+    });
+    const formatVideoId = parseId(videoId);
+    const fileDocId = `videos/${formatVideoId}`;
+    const edge = {
+        _from: itemDocId,
+        _key: edgeId,
+        _to: fileDocId,
+        added: now,
+        itemType
+    };
+    if (itemDocId) {
+        return useDb(databaseName).collection('hasVideo').save(edge, {
+            returnNew: true
+        }).then((fileEdge)=>useDb(databaseName).collection('hasVideo').document(fileEdge)).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+    }
+    return null;
+};
+export const updateVideo = async (context, video, s3Options)=>{
+    const action = 'updateVideo';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const { base64 = '', buffer: videoBuffer, description = '', externalId, externalUrl, fileType, itemId, itemType, provider, type, url = '', videoId } = video;
+    const now = Date.now();
+    const formatVideoId = videoId || createHash(`video-${sessionId}`);
+    const formatItemId = parseId(itemId);
+    const formatItemType = parseChar(itemType, 16).toLowerCase();
+    if (type === 'external' && (externalId || externalUrl)) {
+        const insert = {
+            _key: formatVideoId,
+            added: now,
+            description,
+            externalId,
+            externalUrl,
+            modified: now,
+            provider,
+            type,
+            userId: sessionId
+        };
+        const aqlQry = aql`UPSERT {_key: ${formatVideoId}} INSERT ${insert} UPDATE ${insert} IN videos RETURN NEW`;
+        return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).then((newVideo)=>{
+            if (formatItemId && formatItemType) {
+                const videoEdge = {
+                    videoId: formatVideoId,
+                    itemId: formatItemId,
+                    itemType: formatItemType
+                };
+                return addVideoEdge(context, videoEdge).then(()=>newVideo);
+            }
+            return newVideo;
+        }).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+    }
+    if (base64 || videoBuffer) {
+        let buffer = videoBuffer;
+        if (base64) {
+            const formatBase64 = base64.substr(base64.indexOf(',') + 1);
+            buffer = Buffer.from(formatBase64, 'base64');
+        }
+        let updatedFileType = fileType;
+        if (!fileType) {
+            const { fileTypeFromBuffer } = await import('file-type');
+            const { mime } = await fileTypeFromBuffer(buffer);
+            updatedFileType = mime;
+        }
+        const vParams = {
+            buffer,
+            fileType: updatedFileType,
+            userId: sessionId,
+            videoId: formatVideoId
+        };
+        return addVideo(context, {
+            ...vParams,
+            description
+        }, s3Options).then((newVideo)=>{
+            if (formatItemId && formatItemType) {
+                const videoEdge = {
+                    videoId: formatVideoId,
+                    itemId: formatItemId,
+                    itemType: formatItemType
+                };
+                return addVideoEdge(context, videoEdge).then(()=>newVideo);
+            }
+            return newVideo;
+        }).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+    } else if (url !== '') {
+        let contentType;
+        return httpGet(url).then((res)=>{
+            if (res.status !== 200) {
+                throw new Error(ErrorTypes.IMAGE_REQUEST);
+            }
+            contentType = res.headers.get('content-type');
+            return res;
+        }).then((res)=>res.buffer()).then((buffer)=>{
+            const vParams = {
+                buffer,
+                description,
+                fileType: contentType,
+                userId: sessionId,
+                videoId: formatVideoId
+            };
+            return addVideo(context, vParams, s3Options).then((newVideo)=>{
+                if (formatItemId && formatItemType) {
+                    const videoEdge = {
+                        videoId: formatVideoId,
+                        itemId: formatItemId,
+                        itemType: formatItemType
+                    };
+                    return addVideoEdge(context, videoEdge).then(()=>newVideo);
+                }
+                return newVideo;
+            }).catch((error)=>logError({
+                    action,
+                    category: eventCategory,
+                    value: ErrorTypes.DATABASE_ERROR
+                }, error, context));
+        }).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+    } else if (videoId !== '') {
+        const update = {
+            description,
+            modified: now
+        };
+        const aqlQry = aql`UPDATE {_key: ${formatVideoId}} WITH ${update} IN videos RETURN NEW`;
+        return useDb(databaseName).query(aqlQry).then((cursor)=>cursor.next()).catch((error)=>logError({
+                action,
+                category: eventCategory,
+                value: ErrorTypes.DATABASE_ERROR
+            }, error, context));
+    }
+    return null;
+};
+export const deleteVideo = async (context, videoId)=>{
+    const action = 'deleteVideo';
+    const { databaseName, session: { userId: sessionId } } = context;
+    const formatVideoId = parseId(videoId);
+    try {
+        const videoDocId = `videos/${formatVideoId}`;
+        const removeEdgeQuery = aql`FOR hv IN hasVideo FILTER hv._to == ${videoDocId} REMOVE hv IN hasVideo RETURN OLD`;
+        await useDb(databaseName).query(removeEdgeQuery);
+        const aqlQuery = aql`FOR v IN videos FILTER v._key == ${formatVideoId} && v.userId == ${sessionId} REMOVE v IN videos RETURN OLD`;
+        const video = await useDb(databaseName).query(aqlQuery).then((cursor)=>cursor.next());
+        if (video) {
+            const { _key: vKey } = video;
+            const params = {
+                Bucket: null,
+                Delete: {
+                    Objects: [
+                        {
+                            Key: `users/${sessionId}/videos/${vKey}.mp4`
+                        }
+                    ],
+                    Quiet: true
+                }
+            };
+            return s3DeleteList(params).then(()=>video);
+        }
+        return null;
+    } catch (error) {
+        return logError({
+            action,
+            category: eventCategory,
+            value: ErrorTypes.DATABASE_ERROR
+        }, error, context);
+    }
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/reaktor/src/actions/videos.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 {DeleteObjectsCommandInput, PutObjectCommandInput} from '@aws-sdk/client-s3';\nimport {get as httpGet} from '@nlabs/rip-hunter';\nimport {createHash, parseArangoId, parseChar, parseId} from '@nlabs/utils/parsers/strings';\nimport {aql} from 'arangojs';\nimport {AqlQuery} from 'arangojs/aql';\n\nimport {Config} from '../config.js';\nimport {ErrorTypes} from '../types/error.types.js';\nimport {logError} from '../utils/analyticsUtils.js';\nimport {getDocId, getLimit, selectReactionCountByType, useDb} from '../utils/arangodbUtils.js';\nimport {s3DeleteList, s3GetSignedUrl, s3Put} from './s3.js';\n\nimport type {ArangoDbCollection, ArangoDbLimit} from '../types/arangodb.types.js';\nimport type {ApiContext} from '../types/auth.types.js';\nimport type {VideoEdgeType, VideoOptions, VideoType, VideoUrlData} from '../types/videos.types.js';\n\nconst eventCategory: string = 'videos';\n\nexport const parseVideoOptions = (options: VideoOptions = {}) => {\n  const {from = 0, to = 30, type = 'default'} = options;\n\n  return {\n    limit: getLimit(from, to) as ArangoDbLimit,\n    type: parseChar(type, 32)\n  };\n};\n\nexport const getVideoOptional = (fields: string[] = []) =>\n  fields.reduce((selects, field: string) => {\n    if(field.includes('Count')) {\n      return selectReactionCountByType('videos', 'v', field, selects);\n    }\n\n    switch(field) {\n      case 'reactions': {\n        selects.queries.push(`LET reactions = (FOR video, r IN INBOUND v._id reactions COLLECT reactionName = r.value INTO reactionItems RETURN {name: reactionName, count: LENGTH(reactionItems[*].r.value)})`);\n        selects.objects.push('reactions:reactions');\n        return selects;\n      }\n      case 'tags': {\n        selects.queries.push(`LET tags = (FOR t, pl IN INBOUND v._id isTagged RETURN t)`);\n        selects.objects.push('tags:tags');\n        return selects;\n      }\n      case 'users': {\n        selects.queries.push(`LET users = FIRST(FOR u IN users FILTER v.userId == u._key LIMIT 1 RETURN u)`);\n        selects.objects.push('users:users');\n        return selects;\n      }\n      default: {\n        return selects;\n      }\n    }\n  }, {objects: [], queries: []});\n\nexport const getVideosByUser = (\n  context: ApiContext,\n  userId: string,\n  from: number = 0,\n  to: number = 30\n): Promise<VideoType[]> => {\n  const action: string = 'getVideosByUser';\n  const {databaseName} = context;\n  const formatUserId: string = parseId(userId);\n  const limit: ArangoDbLimit = getLimit(from, to);\n  const aqlQry: string = `FOR v IN videos\n      FILTER v.userId == \"${formatUserId}\"\n      LET user = FIRST(FOR u IN users FILTER u._key == v.userId LIMIT 1 RETURN u)\n      ${limit.aql}\n      SORT v.added\n      RETURN MERGE(v, {user:user})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as VideoType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n      return [] as VideoType[];\n    });\n};\n\nexport const getVideoCountByItem = (context: ApiContext, itemId: string): Promise<number> => {\n  const action: string = 'getVideoCountByItem';\n  const {databaseName} = context;\n  const formatItemId: string = parseArangoId(itemId);\n  const aqlQry: AqlQuery = aql`FOR v IN hasVideo FILTER v._to == ${formatItemId} RETURN {count: COUNT(v)}`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .then(({count}) => count)\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const getVideosByItem = async (\n  context: ApiContext,\n  itemId: string,\n  options: VideoOptions = {}\n): Promise<VideoType[]> => {\n  const action: string = 'getVideosByItem';\n  const {databaseName, fields = []} = context;\n  const formatItemId: string = parseArangoId(itemId);\n  const {limit} = parseVideoOptions(options);\n  const {objects: selectObjects, queries: selectQueries} = getVideoOptional(fields);\n  const aqlQry: string = `FOR v, l IN 1..1 OUTBOUND \"${formatItemId}\" hasVideo\n    FILTER NOT IS_NULL(v)\n    ${selectQueries.join('\\n')}\n    SORT v.added\n    ${limit.aql}\n    RETURN MERGE(v, {${selectObjects.join(', ')}})`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.all() as unknown as VideoType[])\n    .catch((error: Error) => {\n      logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context);\n      return [] as VideoType[];\n    });\n};\n\nexport const getVideo = (context: ApiContext, videoId: string): Promise<VideoType> => {\n  const action: string = 'getVideo';\n  const {databaseName} = context;\n  const formatVideoId: string = parseId(videoId);\n  const aqlQry: AqlQuery = aql`FOR v IN videos FILTER v._key==${formatVideoId} LIMIT 1 RETURN v`;\n\n  return useDb(databaseName).query(aqlQry)\n    .then((cursor) => cursor.next())\n    .catch((error: Error) => logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error, context));\n};\n\nexport const getPathUserVideos = (userId: string, videoId: string, videoType: string, dir: string = 'videos'): string => {\n  let filename: string = videoId;\n\n  switch(videoType) {\n    case 'video/webm':\n      filename = `${videoId}.webm`;\n      break;\n    case 'video/quicktime':\n      filename = `${videoId}.mov`;\n      break;\n    default:\n      filename = `${videoId}.mp4`;\n      break;\n  }\n\n  return `users/${userId}/${dir}/${filename}`;\n};\n\nexport const getAppVideoUrl = ({\n  bucket,\n  directory = 'videos',\n  isThumb = false,\n  type,\n  typeId,\n  videoId\n}: VideoUrlData): string => {\n  if(!type) {\n    return '';\n  }\n\n  if(!videoId) {\n    return '';\n  }\n\n  const bucketName = bucket || Config.get('image.bucket') || 'dev.reaktor.io';\n  const videoName = `${videoId}.mp4`;\n  const videoUrl = Config.get('image.url') || `https://s3.amazonaws.com/${bucketName}`;\n\n  if(type === 'apps') {\n    return `${videoUrl}/${type}/${directory}/${videoName}`;\n  }\n\n  return `${videoUrl}/${type}/${typeId}/${directory}/${videoName}`;\n};\n\nexport const getVideoUrl = async ({\n  bucket,\n  imageDir = 'videos',\n  videoDir = 'videos',\n  videoId,\n  type,\n  typeId,\n  urlType = 'public'\n}: any): Promise<string> => {\n  if(!videoId) {\n    return '';\n  }\n\n  const keyDir = videoDir || imageDir || 'videos';\n  const videoKey: string = `${type}/${typeId}/${keyDir}/${videoId}.mp4`;\n\n  switch(urlType) {\n    case 'signed': {\n      const defaultBucket = Config.get('image.bucket') || 'dev.reaktor.io';\n      return await s3GetSignedUrl({Bucket: bucket || defaultBucket, Expires: 900, Key: videoKey});\n    }\n    case 'public': {\n      return `https://box.${Config.get('app.url')}/${videoKey}`;\n    }\n    case 'dev': {\n      return `https://s3.amazonaws.com/dev.${Config.get('app.url')}/${videoKey}`;\n    }\n    default: {\n      return '';\n    }\n  }\n};\n\nexport const saveVideo = async (\n  context: ApiContext,\n  videoId: string,\n  buffer: Buffer,\n  fileType: string = 'video/mp4', s3Options?: PutObjectCommandInput\n): Promise<VideoType> => {\n  const {session: {userId: sessionId}} = context;\n\n  const videoObj: PutObjectCommandInput = {\n    ACL: 'authenticated-read',\n    Body: buffer,\n    Bucket: null,\n    ContentType: fileType,\n    ...(s3Options || {}),\n    Key: getPathUserVideos(sessionId, videoId, fileType, 'videos')\n  };\n\n  await s3Put(videoObj);\n\n  return {\n    fileSize: buffer.length,\n    fileType,\n    videoId\n  } as unknown as VideoType;\n};\n\nexport const addVideo = (\n  context: ApiContext,\n  video: VideoType,\n  s3Options?: PutObjectCommandInput\n): Promise<VideoType> => {\n  const action: string = 'addVideo';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {videoId, description, buffer, fileType, type = 'video', provider, externalId, externalUrl} = video;\n  const now: number = Date.now();\n\n  if(type === 'external') {\n    const insert: VideoType = {\n      _key: videoId,\n      added: now,\n      description,\n      externalId,\n      externalUrl,\n      provider,\n      type,\n      userId: sessionId\n    } as VideoType;\n\n    const aqlQry: AqlQuery = aql`INSERT ${insert} IN videos RETURN NEW`;\n    return useDb(databaseName).query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n  }\n\n  return saveVideo(context, videoId, buffer, fileType, s3Options)\n    .then((saved: VideoType) => {\n      const insert: VideoType = {\n        ...saved,\n        _key: videoId,\n        added: now,\n        description,\n        fileType,\n        modified: now,\n        type,\n        userId: sessionId\n      } as VideoType;\n\n      const aqlQry: AqlQuery = aql`INSERT ${insert} IN videos 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          value: ErrorTypes.DATABASE_ERROR\n        }, error, context));\n    });\n};\n\nexport const addVideoEdge = async (context: ApiContext, videoEdge: VideoEdgeType): Promise<object> => {\n  const action: string = 'addVideoEdge';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {videoId, itemId, itemType} = videoEdge;\n  const now: number = Date.now();\n  const edgeId: string = createHash(`hasVideo-${videoId}-${itemId}-${sessionId}`);\n  const formatItemType: ArangoDbCollection = parseChar(itemType).toLowerCase() as ArangoDbCollection;\n  const formatItemId: string = parseId(itemId);\n  const itemDocId: string = getDocId(formatItemType, {_key: formatItemId});\n  const formatVideoId: string = parseId(videoId);\n  const fileDocId: string = `videos/${formatVideoId}`;\n\n  const edge: VideoEdgeType = {\n    _from: itemDocId,\n    _key: edgeId,\n    _to: fileDocId,\n    added: now,\n    itemType\n  } as VideoEdgeType;\n\n  if(itemDocId) {\n    return useDb(databaseName).collection('hasVideo').save(edge, {returnNew: true})\n      .then((fileEdge) => useDb(databaseName).collection('hasVideo').document(fileEdge))\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n  }\n\n  return null;\n};\n\nexport const updateVideo = async (\n  context: ApiContext,\n  video: VideoType,\n  s3Options?: PutObjectCommandInput\n): Promise<VideoType> => {\n  const action: string = 'updateVideo';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const {\n    base64 = '',\n    buffer: videoBuffer,\n    description = '',\n    externalId,\n    externalUrl,\n    fileType,\n    itemId,\n    itemType,\n    provider,\n    type,\n    url = '',\n    videoId\n  } = video;\n\n  const now: number = Date.now();\n  const formatVideoId: string = videoId || createHash(`video-${sessionId}`);\n  const formatItemId: string = parseId(itemId);\n  const formatItemType: ArangoDbCollection = parseChar(itemType, 16).toLowerCase() as ArangoDbCollection;\n\n  if(type === 'external' && (externalId || externalUrl)) {\n    const insert: VideoType = {\n      _key: formatVideoId,\n      added: now,\n      description,\n      externalId,\n      externalUrl,\n      modified: now,\n      provider,\n      type,\n      userId: sessionId\n    } as VideoType;\n    const aqlQry: AqlQuery = aql`UPSERT {_key: ${formatVideoId}} INSERT ${insert} UPDATE ${insert} IN videos RETURN NEW`;\n    return useDb(databaseName).query(aqlQry)\n      .then((cursor) => cursor.next())\n      .then((newVideo: VideoType) => {\n        if(formatItemId && formatItemType) {\n          const videoEdge: VideoEdgeType = {videoId: formatVideoId, itemId: formatItemId, itemType: formatItemType};\n          return addVideoEdge(context, videoEdge).then(() => newVideo);\n        }\n        return newVideo;\n      })\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n  }\n\n  if(base64 || videoBuffer) {\n    let buffer: Buffer = videoBuffer as Buffer;\n    if(base64) {\n      const formatBase64: string = base64.substr(base64.indexOf(',') + 1);\n      buffer = Buffer.from(formatBase64, 'base64');\n    }\n\n    let updatedFileType = fileType;\n    if(!fileType) {\n      const {fileTypeFromBuffer} = await import('file-type');\n      const {mime} = await fileTypeFromBuffer(buffer);\n      updatedFileType = mime;\n    }\n\n    const vParams: VideoType = {buffer, fileType: updatedFileType, userId: sessionId, videoId: formatVideoId} as VideoType;\n    return addVideo(context, {...vParams, description}, s3Options)\n      .then((newVideo: VideoType) => {\n        if(formatItemId && formatItemType) {\n          const videoEdge: VideoEdgeType = {videoId: formatVideoId, itemId: formatItemId, itemType: formatItemType};\n          return addVideoEdge(context, videoEdge).then(() => newVideo);\n        }\n        return newVideo;\n      })\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n  } else if(url !== '') {\n    let contentType;\n    return httpGet(url)\n      .then((res: any) => {\n        if(res.status !== 200) {\n          throw new Error(ErrorTypes.IMAGE_REQUEST);\n        }\n        contentType = res.headers.get('content-type');\n        return res;\n      })\n      .then((res) => res.buffer())\n      .then((buffer: Buffer) => {\n        const vParams: VideoType = {buffer, description, fileType: contentType, userId: sessionId, videoId: formatVideoId} as VideoType;\n        return addVideo(context, vParams, s3Options)\n          .then((newVideo: VideoType) => {\n            if(formatItemId && formatItemType) {\n              const videoEdge: VideoEdgeType = {videoId: formatVideoId, itemId: formatItemId, itemType: formatItemType};\n              return addVideoEdge(context, videoEdge).then(() => newVideo);\n            }\n            return newVideo;\n          })\n          .catch((error: Error) => logError({\n            action,\n            category: eventCategory,\n            value: ErrorTypes.DATABASE_ERROR\n          }, error, context));\n      })\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n  } else if(videoId !== '') {\n    const update = {description, modified: now};\n    const aqlQry: AqlQuery = aql`UPDATE {_key: ${formatVideoId}} WITH ${update} IN videos RETURN NEW`;\n    return useDb(databaseName).query(aqlQry)\n      .then((cursor) => cursor.next())\n      .catch((error: Error) => logError({\n        action,\n        category: eventCategory,\n        value: ErrorTypes.DATABASE_ERROR\n      }, error, context));\n  }\n\n  return null as unknown as VideoType;\n};\n\nexport const deleteVideo = async (context: ApiContext, videoId: string): Promise<VideoType> => {\n  const action: string = 'deleteVideo';\n  const {databaseName, session: {userId: sessionId}} = context;\n  const formatVideoId = parseId(videoId);\n\n  try {\n    const videoDocId = `videos/${formatVideoId}`;\n    const removeEdgeQuery = aql`FOR hv IN hasVideo FILTER hv._to == ${videoDocId} REMOVE hv IN hasVideo RETURN OLD`;\n    await useDb(databaseName).query(removeEdgeQuery);\n\n    const aqlQuery = aql`FOR v IN videos FILTER v._key == ${formatVideoId} && v.userId == ${sessionId} REMOVE v IN videos RETURN OLD`;\n    const video = await useDb(databaseName).query(aqlQuery).then((cursor) => cursor.next());\n\n    if(video) {\n      const {_key: vKey} = video;\n      const params: DeleteObjectsCommandInput = {\n        Bucket: null,\n        Delete: {\n          Objects: [\n            {Key: `users/${sessionId}/videos/${vKey}.mp4`}\n          ],\n          Quiet: true\n        }\n      };\n      return s3DeleteList(params).then(() => video);\n    }\n\n    return null as unknown as VideoType;\n  } catch(error) {\n    return logError({\n      action,\n      category: eventCategory,\n      value: ErrorTypes.DATABASE_ERROR\n    }, error as Error, context);\n  }\n};\n\n\n"],"names":["get","httpGet","createHash","parseArangoId","parseChar","parseId","aql","Config","ErrorTypes","logError","getDocId","getLimit","selectReactionCountByType","useDb","s3DeleteList","s3GetSignedUrl","s3Put","eventCategory","parseVideoOptions","options","from","to","type","limit","getVideoOptional","fields","reduce","selects","field","includes","queries","push","objects","getVideosByUser","context","userId","action","databaseName","formatUserId","aqlQry","query","then","cursor","all","catch","error","category","value","DATABASE_ERROR","getVideoCountByItem","itemId","formatItemId","next","count","getVideosByItem","selectObjects","selectQueries","join","getVideo","videoId","formatVideoId","getPathUserVideos","videoType","dir","filename","getAppVideoUrl","bucket","directory","isThumb","typeId","bucketName","videoName","videoUrl","getVideoUrl","imageDir","videoDir","urlType","keyDir","videoKey","defaultBucket","Bucket","Expires","Key","saveVideo","buffer","fileType","s3Options","session","sessionId","videoObj","ACL","Body","ContentType","fileSize","length","addVideo","video","description","provider","externalId","externalUrl","now","Date","insert","_key","added","saved","modified","addVideoEdge","videoEdge","itemType","edgeId","formatItemType","toLowerCase","itemDocId","fileDocId","edge","_from","_to","collection","save","returnNew","fileEdge","document","updateVideo","base64","videoBuffer","url","newVideo","formatBase64","substr","indexOf","Buffer","updatedFileType","fileTypeFromBuffer","mime","vParams","contentType","res","status","Error","IMAGE_REQUEST","headers","update","deleteVideo","videoDocId","removeEdgeQuery","aqlQuery","vKey","params","Delete","Objects","Quiet"],"mappings":"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"}

package/lib/actions/websockets.d.ts

@@ -18,3 +18,4 @@ export declare class WebsocketClient {
     setupClient({ requestContext }: WebSocketClientContext): Promise<void>;
     send(connection: any, payload: any): Promise<boolean>;
 }
+//# sourceMappingURL=websockets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"websockets.d.ts","sourceRoot":"","sources":["../../src/actions/websockets.ts"],"names":[],"mappings":"AAUA,OAAO,EAAC,UAAU,EAAC,MAAM,wBAAwB,CAAC;AAKlD,OAAO,KAAK,EAAC,mBAAmB,EAAC,MAAM,8BAA8B,CAAC;AAGtE,eAAO,MAAM,SAAS,GAAU,UAAU,MAAM,EAAE,OAAO,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAwC5F,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,QAAQ,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAc3E,CAAC;AAEF,eAAO,MAAM,aAAa,GAAI,UAAU,MAAM,KAAG,OAAO,CAAC,GAAG,CAoB3D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,SAAS,UAAU,EAAE,SAAS,MAAM,KAAG,OAAO,CAAC,GAAG,CAqBtF,CAAC;AAEF,eAAO,MAAM,YAAY,GAAI,UAAU,MAAM,KAAG,OAAO,CAAC,mBAAmB,CAoB1E,CAAC;AAEF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,cAAc,CAAC,EAAE;QACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;QAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;KACxB,CAAC;CACH;AACD,qBAAa,eAAe;IAC1B,MAAM,MAAC;gBAEK,MAAM,CAAC,KAAA;IAOb,WAAW,CAAC,EAAC,cAAc,EAAC,EAAE,sBAAsB;IAiBpD,IAAI,CAAC,UAAU,KAAA,EAAE,OAAO,KAAA;CA2B/B"}