@nlabs/metropolisjs 0.1.1 → 0.2.0

package/lib/actions/videoActions/videoActions.d.ts

@@ -0,0 +1,41 @@
+import type { FluxFramework } from '@nlabs/arkhamjs';
+import type { VideoMultipartUploadType, VideoType, VideoUploadPartInput, VideoUploadPartUrl } from '../../types/videos.types.js';
+import type { ActionRequestOptions } from '../../utils/requestCache.js';
+import type { BaseAdapterOptions } from '../../utils/validatorFactory.js';
+export type VideoAdapterOptions = BaseAdapterOptions;
+export interface VideoActionsOptions {
+    readonly videoAdapter?: (input: unknown, options?: VideoAdapterOptions) => any;
+    readonly videoAdapterOptions?: VideoAdapterOptions;
+}
+export type VideoApiResultsType = {
+    readonly videos: {
+        readonly add?: VideoType;
+        readonly abortMultipartUpload?: boolean;
+        readonly completeMultipartUpload?: VideoType;
+        readonly createMultipartUpload?: VideoMultipartUploadType;
+        readonly getMultipartUploadPartUrls?: VideoUploadPartUrl[];
+        readonly getVideoById?: VideoType;
+        readonly getVideoListByItem?: VideoType[];
+        readonly getVideoListByReactions?: VideoType[];
+        readonly list?: VideoType[];
+        readonly remove?: VideoType;
+        readonly update?: VideoType;
+    };
+};
+export interface VideoActions {
+    readonly add: (videoData: Partial<VideoType>, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType>;
+    readonly abortMultipartUpload: (videoId: string, uploadId: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;
+    readonly completeMultipartUpload: (videoId: string, uploadId: string, parts: VideoUploadPartInput[], videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType>;
+    readonly createMultipartUpload: (videoData: Partial<VideoType>, partCount: number, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoMultipartUploadType>;
+    readonly delete: (videoId: string, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType>;
+    readonly getMultipartUploadPartUrls: (videoId: string, uploadId: string, partNumbers: number[], requestOptions?: ActionRequestOptions) => Promise<VideoUploadPartUrl[]>;
+    readonly getVideoById: (videoId: string, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType>;
+    readonly list: (from?: number, to?: number, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType[]>;
+    readonly listByItem: (itemId: string, from?: number, to?: number, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType[]>;
+    readonly listByReactions: (reactions: string[], from?: number, to?: number, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType[]>;
+    readonly update: (video: Partial<VideoType>, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType>;
+    readonly updateVideoAdapter: (adapter: (input: unknown, options?: VideoAdapterOptions) => any) => void;
+    readonly updateVideoAdapterOptions: (options: VideoAdapterOptions) => void;
+}
+export declare const createVideoActions: (flux: FluxFramework, options?: VideoActionsOptions) => VideoActions;
+//# sourceMappingURL=videoActions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"videoActions.d.ts","sourceRoot":"","sources":["../../../src/actions/videoActions/videoActions.ts"],"names":[],"mappings":"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"}

package/lib/actions/videoActions/videoActions.js

@@ -0,0 +1,532 @@
+/**
+ * Copyright (c) 2026-Present, Nitrogen Labs, Inc.
+ * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.
+ */ import { parseId, parseNum } from '@nlabs/utils';
+import { validateVideoInput } from '../../adapters/videoAdapter/videoAdapter.js';
+import { VIDEO_CONSTANTS } from '../../stores/videoStore.js';
+import { appMutation, appQuery } from '../../utils/api.js';
+import { createBaseActions } from '../../utils/baseActionFactory.js';
+import { clearCachedRequest, getCachedRequest, setCachedRequest } from '../../utils/requestCache.js';
+const DATA_TYPE = 'videos';
+const defaultVideoValidator = (input, options)=>validateVideoInput(input);
+export const createVideoActions = (flux, options)=>{
+    const videoBase = createBaseActions(flux, defaultVideoValidator, {
+        adapter: options?.videoAdapter,
+        adapterOptions: options?.videoAdapterOptions
+    });
+    const add = async (videoData, videoProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                video: {
+                    type: 'VideoInput!',
+                    value: videoBase.validator(videoData)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const video = data?.videos?.add || {};
+                await flux.dispatch({
+                    type: VIDEO_CONSTANTS.ADD_ITEM_SUCCESS,
+                    video
+                });
+                return video;
+            };
+            return await appMutation(flux, 'add', DATA_TYPE, queryVariables, [
+                'videoId',
+                ...videoProps
+            ], {
+                onSuccess: onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'video.list');
+            await clearCachedRequest(flux, `video.listByItem:${String(videoData?.itemId || '')}`);
+            await clearCachedRequest(flux, 'video.listByReactions');
+        }
+    };
+    const getVideoById = async (videoId, videoProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `video.getVideoById:${videoId}`, {
+                videoId,
+                videoProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                videoId: {
+                    type: 'ID!',
+                    value: parseId(videoId)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const video = data?.videos?.getVideoById || {};
+                await flux.dispatch({
+                    type: VIDEO_CONSTANTS.GET_ITEM_SUCCESS,
+                    video
+                });
+                return video;
+            };
+            const result = await appQuery(flux, 'getVideoById', DATA_TYPE, queryVariables, [
+                'description',
+                'duration',
+                'format',
+                'height',
+                'mimeType',
+                'name',
+                'privacy',
+                'size',
+                'thumbUrl',
+                'url',
+                'userId',
+                'videoId',
+                'width',
+                ...videoProps
+            ], {
+                onSuccess: onSuccess
+            });
+            return await setCachedRequest(flux, `video.getVideoById:${videoId}`, {
+                videoId,
+                videoProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.GET_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const createMultipartUpload = async (videoData, partCount, videoProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                partCount: {
+                    type: 'Int!',
+                    value: parseNum(partCount)
+                },
+                video: {
+                    type: 'VideoInput!',
+                    value: videoBase.validator(videoData)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const upload = data?.videos?.createMultipartUpload || {};
+                const video = upload?.video || {};
+                await flux.dispatch({
+                    type: VIDEO_CONSTANTS.ADD_ITEM_SUCCESS,
+                    video
+                });
+                return upload;
+            };
+            return await appMutation(flux, 'createMultipartUpload', DATA_TYPE, queryVariables, [
+                'bucket',
+                'key',
+                'partSize',
+                'uploadId',
+                'videoId',
+                'partUrls {partNumber url}',
+                `video {videoId ${videoProps.join(' ')}}`
+            ], {
+                onSuccess: onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.ADD_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, 'video.list');
+            await clearCachedRequest(flux, `video.listByItem:${String(videoData?.itemId || '')}`);
+            await clearCachedRequest(flux, 'video.listByReactions');
+        }
+    };
+    const getMultipartUploadPartUrls = async (videoId, uploadId, partNumbers, requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                partNumbers: {
+                    type: '[Int!]!',
+                    value: partNumbers.map((partNumber)=>parseNum(partNumber))
+                },
+                uploadId: {
+                    type: 'String!',
+                    value: uploadId
+                },
+                videoId: {
+                    type: 'ID!',
+                    value: parseId(videoId)
+                }
+            };
+            const onSuccess = async (data)=>data?.videos?.getMultipartUploadPartUrls || [];
+            return await appMutation(flux, 'getMultipartUploadPartUrls', DATA_TYPE, queryVariables, [
+                'partNumber',
+                'url'
+            ], {
+                onSuccess: onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        }
+    };
+    const completeMultipartUpload = async (videoId, uploadId, parts, videoProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                parts: {
+                    type: '[VideoUploadPartInput!]',
+                    value: parts
+                },
+                uploadId: {
+                    type: 'String!',
+                    value: uploadId
+                },
+                videoId: {
+                    type: 'ID!',
+                    value: parseId(videoId)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const video = data?.videos?.completeMultipartUpload || {};
+                await flux.dispatch({
+                    type: VIDEO_CONSTANTS.UPDATE_ITEM_SUCCESS,
+                    video
+                });
+                await flux.dispatch({
+                    type: VIDEO_CONSTANTS.PROCESSING_COMPLETE,
+                    video
+                });
+                return video;
+            };
+            return await appMutation(flux, 'completeMultipartUpload', DATA_TYPE, queryVariables, [
+                'videoId',
+                ...videoProps
+            ], {
+                onSuccess: onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `video.getVideoById:${videoId}`);
+            await clearCachedRequest(flux, 'video.list');
+            await clearCachedRequest(flux, 'video.listByReactions');
+        }
+    };
+    const abortMultipartUpload = async (videoId, uploadId, requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                uploadId: {
+                    type: 'String!',
+                    value: uploadId
+                },
+                videoId: {
+                    type: 'ID!',
+                    value: parseId(videoId)
+                }
+            };
+            const onSuccess = async (data)=>!!data?.videos?.abortMultipartUpload;
+            return await appMutation(flux, 'abortMultipartUpload', DATA_TYPE, queryVariables, [], {
+                onSuccess: onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `video.getVideoById:${videoId}`);
+            await clearCachedRequest(flux, 'video.list');
+            await clearCachedRequest(flux, 'video.listByReactions');
+        }
+    };
+    const list = async (from = 0, to = 10, videoProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'video.list', {
+                from,
+                to,
+                videoProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const list = data?.videos?.list || [];
+                await flux.dispatch({
+                    list,
+                    type: VIDEO_CONSTANTS.GET_LIST_SUCCESS
+                });
+                return list;
+            };
+            const result = await appQuery(flux, 'list', DATA_TYPE, queryVariables, [
+                'description',
+                'duration',
+                'format',
+                'height',
+                'mimeType',
+                'name',
+                'privacy',
+                'size',
+                'thumbUrl',
+                'url',
+                'userId',
+                'videoId',
+                'width',
+                ...videoProps
+            ], {
+                onSuccess: onSuccess
+            });
+            return await setCachedRequest(flux, 'video.list', {
+                from,
+                to,
+                videoProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByItem = async (itemId, from = 0, to = 10, videoProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, `video.listByItem:${itemId}`, {
+                from,
+                itemId,
+                to,
+                videoProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                itemId: {
+                    type: 'ID!',
+                    value: parseId(itemId)
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const list = data?.videos?.getVideoListByItem || [];
+                await flux.dispatch({
+                    list,
+                    type: VIDEO_CONSTANTS.GET_LIST_SUCCESS
+                });
+                return list;
+            };
+            const result = await appQuery(flux, 'getVideoListByItem', DATA_TYPE, queryVariables, [
+                'description',
+                'durationMs',
+                'fileSize',
+                'fileType',
+                'height',
+                'hlsUrl',
+                'playbackFileType',
+                'playbackUrl',
+                'privacy',
+                'thumbUrl',
+                'type',
+                'url',
+                'userId',
+                'videoId',
+                'width',
+                ...videoProps
+            ], {
+                onSuccess: onSuccess
+            });
+            return await setCachedRequest(flux, `video.listByItem:${itemId}`, {
+                from,
+                itemId,
+                to,
+                videoProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const listByReactions = async (reactions, from = 0, to = 10, videoProps = [], requestOptions = {})=>{
+        try {
+            const cachedResult = getCachedRequest(flux, 'video.listByReactions', {
+                from,
+                reactions,
+                to,
+                videoProps
+            }, requestOptions);
+            if (cachedResult !== undefined) {
+                return cachedResult;
+            }
+            const queryVariables = {
+                from: {
+                    type: 'Int',
+                    value: parseNum(from)
+                },
+                reactions: {
+                    type: '[String!]',
+                    value: reactions
+                },
+                to: {
+                    type: 'Int',
+                    value: parseNum(to)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const list = data?.videos?.getVideoListByReactions || [];
+                await flux.dispatch({
+                    list,
+                    type: VIDEO_CONSTANTS.GET_LIST_SUCCESS
+                });
+                return list;
+            };
+            const result = await appQuery(flux, 'getVideoListByReactions', DATA_TYPE, queryVariables, [
+                'description',
+                'durationMs',
+                'fileSize',
+                'fileType',
+                'height',
+                'hlsUrl',
+                'playbackFileType',
+                'playbackUrl',
+                'privacy',
+                'thumbUrl',
+                'type',
+                'url',
+                'userId',
+                'videoId',
+                'width',
+                ...videoProps
+            ], {
+                onSuccess: onSuccess
+            });
+            return await setCachedRequest(flux, 'video.listByReactions', {
+                from,
+                reactions,
+                to,
+                videoProps
+            }, result, requestOptions);
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.GET_LIST_ERROR
+            });
+            throw error;
+        }
+    };
+    const deleteVideo = async (videoId, videoProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                videoId: {
+                    type: 'ID!',
+                    value: parseId(videoId)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const video = data?.videos?.remove || {};
+                await flux.dispatch({
+                    type: VIDEO_CONSTANTS.REMOVE_ITEM_SUCCESS,
+                    video
+                });
+                return video;
+            };
+            return await appMutation(flux, 'remove', DATA_TYPE, queryVariables, [
+                'videoId',
+                ...videoProps
+            ], {
+                onSuccess: onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.REMOVE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `video.getVideoById:${videoId}`);
+            await clearCachedRequest(flux, 'video.list');
+            await clearCachedRequest(flux, 'video.listByReactions');
+        }
+    };
+    const update = async (video, videoProps = [], requestOptions = {})=>{
+        try {
+            const queryVariables = {
+                video: {
+                    type: 'VideoInput!',
+                    value: videoBase.validator(video)
+                }
+            };
+            const onSuccess = async (data)=>{
+                const video = data?.videos?.update || {};
+                await flux.dispatch({
+                    type: VIDEO_CONSTANTS.UPDATE_ITEM_SUCCESS,
+                    video
+                });
+                return video;
+            };
+            return await appMutation(flux, 'update', DATA_TYPE, queryVariables, [
+                'videoId',
+                ...videoProps
+            ], {
+                onSuccess: onSuccess
+            });
+        } catch (error) {
+            flux.dispatch({
+                error,
+                type: VIDEO_CONSTANTS.UPDATE_ITEM_ERROR
+            });
+            throw error;
+        } finally{
+            await clearCachedRequest(flux, `video.getVideoById:${String(video?.videoId || '')}`);
+            await clearCachedRequest(flux, 'video.list');
+            await clearCachedRequest(flux, `video.listByItem:${String(video?.itemId || '')}`);
+            await clearCachedRequest(flux, 'video.listByReactions');
+        }
+    };
+    return {
+        abortMultipartUpload,
+        add,
+        completeMultipartUpload,
+        createMultipartUpload,
+        delete: deleteVideo,
+        getMultipartUploadPartUrls,
+        getVideoById,
+        list,
+        listByItem,
+        listByReactions,
+        update,
+        updateVideoAdapter: videoBase.updateAdapter,
+        updateVideoAdapterOptions: videoBase.updateOptions
+    };
+};
+
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/Users/nitrog7/Development/metropolisjs/src/actions/videoActions/videoActions.ts"],"sourcesContent":["/**\n * Copyright (c) 2026-Present, Nitrogen Labs, Inc.\n * Copyrights licensed under the MIT License. See the accompanying LICENSE file for terms.\n */\nimport {parseId, parseNum} from '@nlabs/utils';\n\nimport {validateVideoInput} from '../../adapters/videoAdapter/videoAdapter.js';\nimport {VIDEO_CONSTANTS} from '../../stores/videoStore.js';\nimport {appMutation, appQuery} from '../../utils/api.js';\nimport {createBaseActions} from '../../utils/baseActionFactory.js';\nimport {clearCachedRequest, getCachedRequest, setCachedRequest} from '../../utils/requestCache.js';\n\nimport type {FluxFramework} from '@nlabs/arkhamjs';\nimport type {VideoMultipartUploadType, VideoType, VideoUploadPartInput, VideoUploadPartUrl} from '../../types/videos.types.js';\nimport type {ActionRequestOptions} from '../../utils/requestCache.js';\nimport type {BaseAdapterOptions} from '../../utils/validatorFactory.js';\n\nconst DATA_TYPE = 'videos';\n\nexport type VideoAdapterOptions = BaseAdapterOptions;\n\nexport interface VideoActionsOptions {\n  readonly videoAdapter?: (input: unknown, options?: VideoAdapterOptions) => any;\n  readonly videoAdapterOptions?: VideoAdapterOptions;\n}\n\nexport type VideoApiResultsType = {\n  readonly videos: {\n    readonly add?: VideoType;\n    readonly abortMultipartUpload?: boolean;\n    readonly completeMultipartUpload?: VideoType;\n    readonly createMultipartUpload?: VideoMultipartUploadType;\n    readonly getMultipartUploadPartUrls?: VideoUploadPartUrl[];\n    readonly getVideoById?: VideoType;\n    readonly getVideoListByItem?: VideoType[];\n    readonly getVideoListByReactions?: VideoType[];\n    readonly list?: VideoType[];\n    readonly remove?: VideoType;\n    readonly update?: VideoType;\n  };\n};\n\nexport interface VideoActions {\n  readonly add: (videoData: Partial<VideoType>, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType>;\n  readonly abortMultipartUpload: (videoId: string, uploadId: string, requestOptions?: ActionRequestOptions) => Promise<boolean>;\n  readonly completeMultipartUpload: (videoId: string, uploadId: string, parts: VideoUploadPartInput[], videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType>;\n  readonly createMultipartUpload: (videoData: Partial<VideoType>, partCount: number, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoMultipartUploadType>;\n  readonly delete: (videoId: string, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType>;\n  readonly getMultipartUploadPartUrls: (videoId: string, uploadId: string, partNumbers: number[], requestOptions?: ActionRequestOptions) => Promise<VideoUploadPartUrl[]>;\n  readonly getVideoById: (videoId: string, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType>;\n  readonly list: (from?: number, to?: number, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType[]>;\n  readonly listByItem: (itemId: string, from?: number, to?: number, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType[]>;\n  readonly listByReactions: (reactions: string[], from?: number, to?: number, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType[]>;\n  readonly update: (video: Partial<VideoType>, videoProps?: string[], requestOptions?: ActionRequestOptions) => Promise<VideoType>;\n  readonly updateVideoAdapter: (adapter: (input: unknown, options?: VideoAdapterOptions) => any) => void;\n  readonly updateVideoAdapterOptions: (options: VideoAdapterOptions) => void;\n}\n\nconst defaultVideoValidator = (input: unknown, options?: VideoAdapterOptions) =>\n  validateVideoInput(input);\n\nexport const createVideoActions = (\n  flux: FluxFramework,\n  options?: VideoActionsOptions\n): VideoActions => {\n  const videoBase = createBaseActions(flux, defaultVideoValidator, {\n    adapter: options?.videoAdapter,\n    adapterOptions: options?.videoAdapterOptions\n  });\n\n  const add = async (\n    videoData: Partial<VideoType>,\n    videoProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<VideoType> => {\n    try {\n      const queryVariables = {\n        video: {\n          type: 'VideoInput!',\n          value: videoBase.validator(videoData)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) => {\n        const video = data?.videos?.add || {};\n        await flux.dispatch({type: VIDEO_CONSTANTS.ADD_ITEM_SUCCESS, video});\n        return video;\n      };\n\n      return await appMutation<VideoType>(\n        flux,\n        'add',\n        DATA_TYPE,\n        queryVariables,\n        ['videoId', ...videoProps],\n        {onSuccess: onSuccess as any}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'video.list');\n      await clearCachedRequest(flux, `video.listByItem:${String(videoData?.itemId || '')}`);\n      await clearCachedRequest(flux, 'video.listByReactions');\n    }\n  };\n\n  const getVideoById = async (videoId: string, videoProps: string[] = [], requestOptions: ActionRequestOptions = {}): Promise<VideoType> => {\n    try {\n      const cachedResult = getCachedRequest<VideoType>(flux, `video.getVideoById:${videoId}`, {videoId, videoProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        videoId: {\n          type: 'ID!',\n          value: parseId(videoId)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) => {\n        const video = data?.videos?.getVideoById || {};\n        await flux.dispatch({type: VIDEO_CONSTANTS.GET_ITEM_SUCCESS, video});\n        return video;\n      };\n\n      const result = await appQuery<VideoType>(\n        flux,\n        'getVideoById',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'description',\n          'duration',\n          'format',\n          'height',\n          'mimeType',\n          'name',\n          'privacy',\n          'size',\n          'thumbUrl',\n          'url',\n          'userId',\n          'videoId',\n          'width',\n          ...videoProps\n        ],\n        {onSuccess: onSuccess as any}\n      );\n      return await setCachedRequest(flux, `video.getVideoById:${videoId}`, {videoId, videoProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.GET_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const createMultipartUpload = async (\n    videoData: Partial<VideoType>,\n    partCount: number,\n    videoProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<VideoMultipartUploadType> => {\n    try {\n      const queryVariables = {\n        partCount: {\n          type: 'Int!',\n          value: parseNum(partCount)\n        },\n        video: {\n          type: 'VideoInput!',\n          value: videoBase.validator(videoData)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) => {\n        const upload = (data?.videos?.createMultipartUpload || {}) as VideoMultipartUploadType;\n        const video = upload?.video || {};\n        await flux.dispatch({type: VIDEO_CONSTANTS.ADD_ITEM_SUCCESS, video});\n        return upload;\n      };\n\n      return await appMutation<VideoMultipartUploadType>(\n        flux,\n        'createMultipartUpload',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'bucket',\n          'key',\n          'partSize',\n          'uploadId',\n          'videoId',\n          'partUrls {partNumber url}',\n          `video {videoId ${videoProps.join(' ')}}`\n        ],\n        {onSuccess: onSuccess as any}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.ADD_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, 'video.list');\n      await clearCachedRequest(flux, `video.listByItem:${String(videoData?.itemId || '')}`);\n      await clearCachedRequest(flux, 'video.listByReactions');\n    }\n  };\n\n  const getMultipartUploadPartUrls = async (\n    videoId: string,\n    uploadId: string,\n    partNumbers: number[],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<VideoUploadPartUrl[]> => {\n    try {\n      const queryVariables = {\n        partNumbers: {\n          type: '[Int!]!',\n          value: partNumbers.map((partNumber) => parseNum(partNumber))\n        },\n        uploadId: {\n          type: 'String!',\n          value: uploadId\n        },\n        videoId: {\n          type: 'ID!',\n          value: parseId(videoId)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) =>\n        data?.videos?.getMultipartUploadPartUrls || [];\n\n      return await appMutation<VideoUploadPartUrl[]>(\n        flux,\n        'getMultipartUploadPartUrls',\n        DATA_TYPE,\n        queryVariables,\n        ['partNumber', 'url'],\n        {onSuccess: onSuccess as any}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    }\n  };\n\n  const completeMultipartUpload = async (\n    videoId: string,\n    uploadId: string,\n    parts: VideoUploadPartInput[],\n    videoProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<VideoType> => {\n    try {\n      const queryVariables = {\n        parts: {\n          type: '[VideoUploadPartInput!]',\n          value: parts\n        },\n        uploadId: {\n          type: 'String!',\n          value: uploadId\n        },\n        videoId: {\n          type: 'ID!',\n          value: parseId(videoId)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) => {\n        const video = data?.videos?.completeMultipartUpload || {};\n        await flux.dispatch({type: VIDEO_CONSTANTS.UPDATE_ITEM_SUCCESS, video});\n        await flux.dispatch({type: VIDEO_CONSTANTS.PROCESSING_COMPLETE, video});\n        return video;\n      };\n\n      return await appMutation<VideoType>(\n        flux,\n        'completeMultipartUpload',\n        DATA_TYPE,\n        queryVariables,\n        ['videoId', ...videoProps],\n        {onSuccess: onSuccess as any}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `video.getVideoById:${videoId}`);\n      await clearCachedRequest(flux, 'video.list');\n      await clearCachedRequest(flux, 'video.listByReactions');\n    }\n  };\n\n  const abortMultipartUpload = async (\n    videoId: string,\n    uploadId: string,\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<boolean> => {\n    try {\n      const queryVariables = {\n        uploadId: {\n          type: 'String!',\n          value: uploadId\n        },\n        videoId: {\n          type: 'ID!',\n          value: parseId(videoId)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) =>\n        !!data?.videos?.abortMultipartUpload;\n\n      return await appMutation<boolean>(\n        flux,\n        'abortMultipartUpload',\n        DATA_TYPE,\n        queryVariables,\n        [],\n        {onSuccess: onSuccess as any}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `video.getVideoById:${videoId}`);\n      await clearCachedRequest(flux, 'video.list');\n      await clearCachedRequest(flux, 'video.listByReactions');\n    }\n  };\n\n  const list = async (\n    from: number = 0,\n    to: number = 10,\n    videoProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<VideoType[]> => {\n    try {\n      const cachedResult = getCachedRequest<VideoType[]>(flux, 'video.list', {from, to, videoProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) => {\n        const list = data?.videos?.list || [];\n        await flux.dispatch({\n          list,\n          type: VIDEO_CONSTANTS.GET_LIST_SUCCESS\n        });\n        return list;\n      };\n\n      const result = await appQuery<VideoType[]>(\n        flux,\n        'list',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'description',\n          'duration',\n          'format',\n          'height',\n          'mimeType',\n          'name',\n          'privacy',\n          'size',\n          'thumbUrl',\n          'url',\n          'userId',\n          'videoId',\n          'width',\n          ...videoProps\n        ],\n        {onSuccess: onSuccess as any}\n      );\n      return await setCachedRequest(flux, 'video.list', {from, to, videoProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByItem = async (\n    itemId: string,\n    from: number = 0,\n    to: number = 10,\n    videoProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<VideoType[]> => {\n    try {\n      const cachedResult = getCachedRequest<VideoType[]>(flux, `video.listByItem:${itemId}`, {from, itemId, to, videoProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        itemId: {\n          type: 'ID!',\n          value: parseId(itemId)\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) => {\n        const list = data?.videos?.getVideoListByItem || [];\n        await flux.dispatch({\n          list,\n          type: VIDEO_CONSTANTS.GET_LIST_SUCCESS\n        });\n        return list;\n      };\n\n      const result = await appQuery<VideoType[]>(\n        flux,\n        'getVideoListByItem',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'description',\n          'durationMs',\n          'fileSize',\n          'fileType',\n          'height',\n          'hlsUrl',\n          'playbackFileType',\n          'playbackUrl',\n          'privacy',\n          'thumbUrl',\n          'type',\n          'url',\n          'userId',\n          'videoId',\n          'width',\n          ...videoProps\n        ],\n        {onSuccess: onSuccess as any}\n      );\n      return await setCachedRequest(flux, `video.listByItem:${itemId}`, {from, itemId, to, videoProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const listByReactions = async (\n    reactions: string[],\n    from: number = 0,\n    to: number = 10,\n    videoProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<VideoType[]> => {\n    try {\n      const cachedResult = getCachedRequest<VideoType[]>(flux, 'video.listByReactions', {from, reactions, to, videoProps}, requestOptions);\n\n      if(cachedResult !== undefined) {\n        return cachedResult;\n      }\n\n      const queryVariables = {\n        from: {\n          type: 'Int',\n          value: parseNum(from)\n        },\n        reactions: {\n          type: '[String!]',\n          value: reactions\n        },\n        to: {\n          type: 'Int',\n          value: parseNum(to)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) => {\n        const list = data?.videos?.getVideoListByReactions || [];\n        await flux.dispatch({\n          list,\n          type: VIDEO_CONSTANTS.GET_LIST_SUCCESS\n        });\n        return list;\n      };\n\n      const result = await appQuery<VideoType[]>(\n        flux,\n        'getVideoListByReactions',\n        DATA_TYPE,\n        queryVariables,\n        [\n          'description',\n          'durationMs',\n          'fileSize',\n          'fileType',\n          'height',\n          'hlsUrl',\n          'playbackFileType',\n          'playbackUrl',\n          'privacy',\n          'thumbUrl',\n          'type',\n          'url',\n          'userId',\n          'videoId',\n          'width',\n          ...videoProps\n        ],\n        {onSuccess: onSuccess as any}\n      );\n      return await setCachedRequest(flux, 'video.listByReactions', {from, reactions, to, videoProps}, result, requestOptions);\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.GET_LIST_ERROR});\n      throw error;\n    }\n  };\n\n  const deleteVideo = async (\n    videoId: string,\n    videoProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<VideoType> => {\n    try {\n      const queryVariables = {\n        videoId: {\n          type: 'ID!',\n          value: parseId(videoId)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) => {\n        const video = data?.videos?.remove || {};\n        await flux.dispatch({type: VIDEO_CONSTANTS.REMOVE_ITEM_SUCCESS, video});\n        return video;\n      };\n\n      return await appMutation<VideoType>(\n        flux,\n        'remove',\n        DATA_TYPE,\n        queryVariables,\n        ['videoId', ...videoProps],\n        {onSuccess: onSuccess as any}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.REMOVE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `video.getVideoById:${videoId}`);\n      await clearCachedRequest(flux, 'video.list');\n      await clearCachedRequest(flux, 'video.listByReactions');\n    }\n  };\n\n  const update = async (\n    video: Partial<VideoType>,\n    videoProps: string[] = [],\n    requestOptions: ActionRequestOptions = {}\n  ): Promise<VideoType> => {\n    try {\n      const queryVariables = {\n        video: {\n          type: 'VideoInput!',\n          value: videoBase.validator(video)\n        }\n      };\n\n      const onSuccess = async (data: VideoApiResultsType) => {\n        const video = data?.videos?.update || {};\n        await flux.dispatch({type: VIDEO_CONSTANTS.UPDATE_ITEM_SUCCESS, video});\n        return video;\n      };\n\n      return await appMutation<VideoType>(\n        flux,\n        'update',\n        DATA_TYPE,\n        queryVariables,\n        ['videoId', ...videoProps],\n        {onSuccess: onSuccess as any}\n      );\n    } catch(error) {\n      flux.dispatch({error, type: VIDEO_CONSTANTS.UPDATE_ITEM_ERROR});\n      throw error;\n    } finally {\n      await clearCachedRequest(flux, `video.getVideoById:${String(video?.videoId || '')}`);\n      await clearCachedRequest(flux, 'video.list');\n      await clearCachedRequest(flux, `video.listByItem:${String(video?.itemId || '')}`);\n      await clearCachedRequest(flux, 'video.listByReactions');\n    }\n  };\n\n  return {\n    abortMultipartUpload,\n    add,\n    completeMultipartUpload,\n    createMultipartUpload,\n    delete: deleteVideo,\n    getMultipartUploadPartUrls,\n    getVideoById,\n    list,\n    listByItem,\n    listByReactions,\n    update,\n    updateVideoAdapter: videoBase.updateAdapter,\n    updateVideoAdapterOptions: videoBase.updateOptions\n  };\n};\n"],"names":["parseId","parseNum","validateVideoInput","VIDEO_CONSTANTS","appMutation","appQuery","createBaseActions","clearCachedRequest","getCachedRequest","setCachedRequest","DATA_TYPE","defaultVideoValidator","input","options","createVideoActions","flux","videoBase","adapter","videoAdapter","adapterOptions","videoAdapterOptions","add","videoData","videoProps","requestOptions","queryVariables","video","type","value","validator","onSuccess","data","videos","dispatch","ADD_ITEM_SUCCESS","error","ADD_ITEM_ERROR","String","itemId","getVideoById","videoId","cachedResult","undefined","GET_ITEM_SUCCESS","result","GET_ITEM_ERROR","createMultipartUpload","partCount","upload","join","getMultipartUploadPartUrls","uploadId","partNumbers","map","partNumber","UPDATE_ITEM_ERROR","completeMultipartUpload","parts","UPDATE_ITEM_SUCCESS","PROCESSING_COMPLETE","abortMultipartUpload","list","from","to","GET_LIST_SUCCESS","GET_LIST_ERROR","listByItem","getVideoListByItem","listByReactions","reactions","getVideoListByReactions","deleteVideo","remove","REMOVE_ITEM_SUCCESS","REMOVE_ITEM_ERROR","update","delete","updateVideoAdapter","updateAdapter","updateVideoAdapterOptions","updateOptions"],"mappings":"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"}