@vived/host 3.0.0

package/lib/Components/VivedAPI/UCs/DeleteAssetUC.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeDeleteAssetUC = exports.DeleteAssetUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+const SignedAuthTokenUC_1 = require("./SignedAuthTokenUC");
+class DeleteAssetUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(DeleteAssetUC.type, appObjects);
+    }
+}
+exports.DeleteAssetUC = DeleteAssetUC;
+DeleteAssetUC.type = "DeleteAssetUC";
+function makeDeleteAssetUC(appObject) {
+    return new DeleteAssetUCImp(appObject);
+}
+exports.makeDeleteAssetUC = makeDeleteAssetUC;
+class DeleteAssetUCImp extends DeleteAssetUC {
+    constructor(appObject) {
+        super(appObject, DeleteAssetUC.type);
+        this.doDelete = (assetID) => {
+            const getAuthToken = this.getAuthToken;
+            const vivedAPI = this.vivedAPI;
+            const jsonRequester = this.jsonRequester;
+            if (!getAuthToken || !vivedAPI || !jsonRequester) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                getAuthToken()
+                    .then((token) => {
+                    const postURL = vivedAPI.getEndpointURL(`assets/${assetID}`);
+                    const options = {
+                        method: "DELETE",
+                        headers: {
+                            Authorization: "Bearer " + token
+                        }
+                    };
+                    return jsonRequester(postURL, options);
+                })
+                    .then((_) => {
+                    resolve();
+                })
+                    .catch((e) => {
+                    reject(e);
+                    return;
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get jsonRequester() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get getAuthToken() {
+        var _a;
+        return (_a = this.getCachedSingleton(SignedAuthTokenUC_1.SignedAuthTokenUC.type)) === null || _a === void 0 ? void 0 : _a.getUserAuthToken;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+}

package/lib/Components/VivedAPI/UCs/FetchAssetFileFromAPIUC.d.ts

@@ -0,0 +1,8 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from '../../../HostAppObject';
+import { AssetEntity } from '../../Assets';
+export declare abstract class FetchAssetFileFromAPIUC extends HostAppObjectUC {
+    static type: string;
+    abstract doFetch(asset: AssetEntity): Promise<File>;
+    static get(appObjects: HostAppObjectRepo): FetchAssetFileFromAPIUC | undefined;
+}
+export declare function makeFetchAssetFileFromAPIUC(appObject: HostAppObject): FetchAssetFileFromAPIUC;

package/lib/Components/VivedAPI/UCs/FetchAssetFileFromAPIUC.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFetchAssetFileFromAPIUC = exports.FetchAssetFileFromAPIUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const BlobRequestUC_1 = require("./BlobRequestUC");
+class FetchAssetFileFromAPIUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(FetchAssetFileFromAPIUC.type, appObjects);
+    }
+}
+exports.FetchAssetFileFromAPIUC = FetchAssetFileFromAPIUC;
+FetchAssetFileFromAPIUC.type = 'FetchAssetFileFromAPIUC';
+function makeFetchAssetFileFromAPIUC(appObject) {
+    return new FetchAssetFileUCImp(appObject);
+}
+exports.makeFetchAssetFileFromAPIUC = makeFetchAssetFileFromAPIUC;
+class FetchAssetFileUCImp extends FetchAssetFileFromAPIUC {
+    constructor(appObject) {
+        super(appObject, FetchAssetFileFromAPIUC.type);
+        this.doFetch = (asset) => {
+            const requestBlob = this.requestBlob;
+            if (!requestBlob) {
+                return Promise.reject();
+            }
+            if (!asset.fileURL) {
+                return Promise.reject(new Error(`${asset.id} does not have a file URL`));
+            }
+            if (!asset.filename) {
+                return Promise.reject(new Error(`${asset.id} does not have a filename`));
+            }
+            return new Promise((resolve, reject) => {
+                const filename = asset.filename;
+                const url = new URL(asset.fileURL);
+                requestBlob(url)
+                    .then((blob) => {
+                    if (blob && filename) {
+                        const file = new File([blob], filename);
+                        resolve(file);
+                    }
+                })
+                    .catch((e) => {
+                    this.warn(e.message);
+                    reject(e);
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get requestBlob() {
+        var _a;
+        return (_a = this.getCachedSingleton(BlobRequestUC_1.BlobRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+}

package/lib/Components/VivedAPI/UCs/FetchAssetFileUC.d.ts

@@ -0,0 +1,8 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+import { AssetEntity } from "../../Assets";
+export declare abstract class FetchAssetFileUC extends HostAppObjectUC {
+    static type: string;
+    abstract doFetch(asset: AssetEntity): Promise<File>;
+    static get(appObjects: HostAppObjectRepo): FetchAssetFileUC | undefined;
+}
+export declare function makeFetchAssetFileUC(appObject: HostAppObject): FetchAssetFileUC;

package/lib/Components/VivedAPI/UCs/FetchAssetFileUC.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFetchAssetFileUC = exports.FetchAssetFileUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const BlobRequestUC_1 = require("./BlobRequestUC");
+class FetchAssetFileUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(FetchAssetFileUC.type, appObjects);
+    }
+}
+exports.FetchAssetFileUC = FetchAssetFileUC;
+FetchAssetFileUC.type = "FetchAssetFileUC";
+function makeFetchAssetFileUC(appObject) {
+    return new FetchAssetFileUCImp(appObject);
+}
+exports.makeFetchAssetFileUC = makeFetchAssetFileUC;
+class FetchAssetFileUCImp extends FetchAssetFileUC {
+    get requestBlob() {
+        var _a;
+        return (_a = this.getCachedSingleton(BlobRequestUC_1.BlobRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    doFetch(asset) {
+        const requestBlob = this.requestBlob;
+        if (!requestBlob) {
+            return Promise.reject();
+        }
+        if (!asset.fileURL) {
+            return Promise.reject(new Error(`${asset.id} does not have a file URL`));
+        }
+        if (!asset.filename) {
+            return Promise.reject(new Error(`${asset.id} does not have a filename`));
+        }
+        return new Promise((resolve, reject) => {
+            const filename = asset.filename;
+            const url = new URL(asset.fileURL);
+            requestBlob(url)
+                .then((blob) => {
+                if (blob && filename) {
+                    const file = new File([blob], filename);
+                    resolve(file);
+                }
+            })
+                .catch((e) => {
+                this.warn(e.message);
+                reject(e);
+            });
+        });
+    }
+    constructor(appObject) {
+        super(appObject, FetchAssetFileUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}

package/lib/Components/VivedAPI/UCs/FetchAssetMetaFromAPIUC.d.ts

@@ -0,0 +1,8 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from '../../../HostAppObject';
+import { AssetDTO } from '../../Assets';
+export declare abstract class FetchAssetMetaFromAPIUC extends HostAppObjectUC {
+    static type: string;
+    abstract doFetch(assetID: string): Promise<AssetDTO>;
+    static get(appObjects: HostAppObjectRepo): FetchAssetMetaFromAPIUC | undefined;
+}
+export declare function makeFetchAssetMetaFromAPIUC(appObject: HostAppObject): FetchAssetMetaFromAPIUC;

package/lib/Components/VivedAPI/UCs/FetchAssetMetaFromAPIUC.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFetchAssetMetaFromAPIUC = exports.FetchAssetMetaFromAPIUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+class FetchAssetMetaFromAPIUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(FetchAssetMetaFromAPIUC.type, appObjects);
+    }
+}
+exports.FetchAssetMetaFromAPIUC = FetchAssetMetaFromAPIUC;
+FetchAssetMetaFromAPIUC.type = 'FetchAssetMetaFromAPIUC';
+function makeFetchAssetMetaFromAPIUC(appObject) {
+    return new FetchAssetMetaUCImp(appObject);
+}
+exports.makeFetchAssetMetaFromAPIUC = makeFetchAssetMetaFromAPIUC;
+class FetchAssetMetaUCImp extends FetchAssetMetaFromAPIUC {
+    constructor(appObject) {
+        super(appObject, FetchAssetMetaFromAPIUC.type);
+        this.doFetch = (assetID) => {
+            const vivedAPI = this.vivedAPI;
+            const requestJSON = this.requestJSON;
+            if (!vivedAPI || !requestJSON) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                const endpointUrl = vivedAPI.getEndpointURL(`assets/${assetID}`);
+                const options = {
+                    method: 'GET',
+                };
+                requestJSON(endpointUrl, options)
+                    .then((resp) => {
+                    const assetDTO = responseToDTO(resp.asset);
+                    assetDTO.id = assetID;
+                    resolve(assetDTO);
+                })
+                    .catch((e) => {
+                    this.warn(e.message);
+                    reject(e);
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get requestJSON() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+}
+function responseToDTO(resp) {
+    const linkedAssets = resp.linkedAssets.map((linkedAssetResp) => {
+        return {
+            type: linkedAssetResp.type,
+            asset: responseToDTO(linkedAssetResp.asset),
+        };
+    });
+    const dto = {
+        archived: resp.archived,
+        description: resp.description,
+        fileURL: resp.fileURL,
+        filename: resp.filename,
+        id: resp.id,
+        name: resp.name,
+        linkedAssets,
+        ownerId: resp.ownerId,
+    };
+    return dto;
+}

package/lib/Components/VivedAPI/UCs/FetchAssetMetaUC.d.ts

@@ -0,0 +1,20 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export interface AssetMetaDTO {
+    id: string;
+    ownerId: string;
+    name: string;
+    description: string;
+    archived: boolean;
+    filename: string;
+    fileURL: string;
+    linkedAssets: {
+        type: string;
+        asset: AssetMetaDTO;
+    }[];
+}
+export declare abstract class FetchAssetMetaUC extends HostAppObjectUC {
+    static type: string;
+    abstract doFetch(assetID: string): Promise<AssetMetaDTO>;
+    static get(appObjects: HostAppObjectRepo): FetchAssetMetaUC | undefined;
+}
+export declare function makeFetchAssetMetaUC(appObject: HostAppObject): FetchAssetMetaUC;

package/lib/Components/VivedAPI/UCs/FetchAssetMetaUC.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFetchAssetMetaUC = exports.FetchAssetMetaUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+class FetchAssetMetaUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(FetchAssetMetaUC.type, appObjects);
+    }
+}
+exports.FetchAssetMetaUC = FetchAssetMetaUC;
+FetchAssetMetaUC.type = "FetchAssetMetaUC";
+function makeFetchAssetMetaUC(appObject) {
+    return new FetchAssetMetaUCImp(appObject);
+}
+exports.makeFetchAssetMetaUC = makeFetchAssetMetaUC;
+class FetchAssetMetaUCImp extends FetchAssetMetaUC {
+    get requestJSON() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+    doFetch(assetID) {
+        const vivedAPI = this.vivedAPI;
+        const requestJSON = this.requestJSON;
+        if (!vivedAPI || !requestJSON) {
+            return Promise.reject();
+        }
+        return new Promise((resolve, reject) => {
+            const endpointUrl = vivedAPI.getEndpointURL(`assets/${assetID}`);
+            const options = {
+                method: "GET"
+            };
+            requestJSON(endpointUrl, options)
+                .then((resp) => {
+                const assetDTO = responseToDTO(resp.asset);
+                assetDTO.id = assetID;
+                resolve(assetDTO);
+            })
+                .catch((e) => {
+                this.warn(e.message);
+                reject(e);
+            });
+        });
+    }
+    constructor(appObject) {
+        super(appObject, FetchAssetMetaUC.type);
+        this.appObjects.registerSingleton(this);
+    }
+}
+function responseToDTO(resp) {
+    const linkedAssets = resp.linkedAssets.map((linkedAssetResp) => {
+        return {
+            type: linkedAssetResp.type,
+            asset: responseToDTO(linkedAssetResp.asset)
+        };
+    });
+    const dto = {
+        archived: resp.archived,
+        description: resp.description,
+        fileURL: resp.fileURL,
+        filename: resp.filename,
+        id: resp.id,
+        name: resp.name,
+        linkedAssets,
+        ownerId: resp.ownerId
+    };
+    return dto;
+}

package/lib/Components/VivedAPI/UCs/FileUploadUC.d.ts

@@ -0,0 +1,7 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from '../../../HostAppObject';
+export declare abstract class FileUploadUC extends HostAppObjectUC {
+    static type: string;
+    abstract doUpload(file: File): Promise<void>;
+    static get(appObjects: HostAppObjectRepo): FileUploadUC | undefined;
+}
+export declare function makeFileUploadUC(appObject: HostAppObject): FileUploadUC;

package/lib/Components/VivedAPI/UCs/FileUploadUC.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeFileUploadUC = exports.FileUploadUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const BasicFetchUC_1 = require("./BasicFetchUC");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+class FileUploadUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(FileUploadUC.type, appObjects);
+    }
+}
+exports.FileUploadUC = FileUploadUC;
+FileUploadUC.type = 'FileUploadUC';
+function makeFileUploadUC(appObject) {
+    return new FileUploadUCImp(appObject);
+}
+exports.makeFileUploadUC = makeFileUploadUC;
+class FileUploadUCImp extends FileUploadUC {
+    constructor(appObject) {
+        super(appObject, FileUploadUC.type);
+        this.doUpload = (file) => {
+            const vivedAPI = this.vivedAPI;
+            const requestJSON = this.requestJSON;
+            const basicFetch = this.basicFetch;
+            if (!vivedAPI || !requestJSON || !basicFetch) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                const getUploadURL = vivedAPI.getEndpointURL(`upload/large/DataVariants/${file.name}`);
+                requestJSON(getUploadURL)
+                    .then((uploadURL) => {
+                    const url = new URL(uploadURL);
+                    const options = {
+                        method: 'PUT',
+                        body: file,
+                    };
+                    return basicFetch(url, options);
+                })
+                    .then((_) => {
+                    resolve();
+                })
+                    .catch((e) => {
+                    this.warn(e.message);
+                    reject(e);
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+    get requestJSON() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get basicFetch() {
+        var _a;
+        return (_a = this.getCachedSingleton(BasicFetchUC_1.BasicFetchUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+}

package/lib/Components/VivedAPI/UCs/GetAppFromAPIUC.d.ts

@@ -0,0 +1,28 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from '../../../HostAppObject';
+export interface GetAppResponseDTO {
+    interfaceVersion: string;
+    assetFolderURL: string;
+    entrypoints: string[];
+}
+export declare abstract class GetAppFromAPIUC extends HostAppObjectUC {
+    static type: string;
+    abstract getApp(appID: string, version: string): Promise<GetAppResponseDTO>;
+    static get(appObjects: HostAppObjectRepo): GetAppFromAPIUC | undefined;
+}
+export declare function makeGetAppFromAPIUC(appObject: HostAppObject): GetAppFromAPIUC;
+export interface GetAppResponse {
+    app: App;
+}
+export interface App {
+    PK: string;
+    SK: string;
+    title?: string;
+    description?: string;
+    image?: string;
+    versions: string[];
+    files: string[];
+    mount_app: string;
+    mount_name: string;
+    appInterfaceVersion: string;
+    baseAssetsUrl: string;
+}

package/lib/Components/VivedAPI/UCs/GetAppFromAPIUC.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAppFromAPIUC = exports.GetAppFromAPIUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+const SignedAuthTokenUC_1 = require("./SignedAuthTokenUC");
+class GetAppFromAPIUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(GetAppFromAPIUC.type, appObjects);
+    }
+}
+exports.GetAppFromAPIUC = GetAppFromAPIUC;
+GetAppFromAPIUC.type = 'GetAppFromAPIUC';
+function makeGetAppFromAPIUC(appObject) {
+    return new GetAppUCImp(appObject);
+}
+exports.makeGetAppFromAPIUC = makeGetAppFromAPIUC;
+class GetAppUCImp extends GetAppFromAPIUC {
+    constructor(appObject) {
+        super(appObject, GetAppFromAPIUC.type);
+        this.getApp = (appID, version) => {
+            const getAuthToken = this.getAuthToken;
+            const vivedAPI = this.vivedAPI;
+            const jsonRequester = this.jsonRequester;
+            if (!getAuthToken || !vivedAPI || !jsonRequester) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                getAuthToken()
+                    .then((token) => {
+                    const endpointURL = vivedAPI.getEndpointURL(`apps/${appID}/${version}`);
+                    endpointURL.searchParams.set('function_version', '2');
+                    const options = {
+                        method: 'GET',
+                        headers: {
+                            Authorization: 'Bearer ' + token,
+                        },
+                    };
+                    return jsonRequester(endpointURL, options);
+                })
+                    .then((resp) => {
+                    const app = resp.app;
+                    const appDTO = {
+                        interfaceVersion: app.appInterfaceVersion,
+                        assetFolderURL: app.baseAssetsUrl,
+                        entrypoints: [...app.files],
+                    };
+                    resolve(appDTO);
+                })
+                    .catch((e) => {
+                    reject(e);
+                    return;
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get jsonRequester() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get getAuthToken() {
+        var _a;
+        return (_a = this.getCachedSingleton(SignedAuthTokenUC_1.SignedAuthTokenUC.type)) === null || _a === void 0 ? void 0 : _a.getUserAuthToken;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+}

package/lib/Components/VivedAPI/UCs/GetAppUC.d.ts

@@ -0,0 +1,28 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from "../../../HostAppObject";
+export interface GetAppResponseDTO {
+    interfaceVersion: string;
+    assetFolderURL: string;
+    entrypoints: string[];
+}
+export declare abstract class GetAppUC extends HostAppObjectUC {
+    static type: string;
+    abstract getApp(appID: string, version: string): Promise<GetAppResponseDTO>;
+    static get(appObjects: HostAppObjectRepo): GetAppUC | undefined;
+}
+export declare function makeGetAppUC(appObject: HostAppObject): GetAppUC;
+export interface GetApp_Response {
+    app: App;
+}
+export interface App {
+    PK: string;
+    SK: string;
+    title?: string;
+    description?: string;
+    image?: string;
+    versions: string[];
+    files: string[];
+    mount_app: string;
+    mount_name: string;
+    appInterfaceVersion: string;
+    baseAssetsUrl: string;
+}

package/lib/Components/VivedAPI/UCs/GetAppUC.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeGetAppUC = exports.GetAppUC = void 0;
+const HostAppObject_1 = require("../../../HostAppObject");
+const VivedAPIEntity_1 = require("../Entities/VivedAPIEntity");
+const JsonRequestUC_1 = require("./JsonRequestUC");
+const SignedAuthTokenUC_1 = require("./SignedAuthTokenUC");
+class GetAppUC extends HostAppObject_1.HostAppObjectUC {
+    static get(appObjects) {
+        return HostAppObject_1.getSingletonComponent(GetAppUC.type, appObjects);
+    }
+}
+exports.GetAppUC = GetAppUC;
+GetAppUC.type = "GetAppUC";
+function makeGetAppUC(appObject) {
+    return new GetAppUCImp(appObject);
+}
+exports.makeGetAppUC = makeGetAppUC;
+class GetAppUCImp extends GetAppUC {
+    constructor(appObject) {
+        super(appObject, GetAppUC.type);
+        this.getApp = (appID, version) => {
+            const getAuthToken = this.getAuthToken;
+            const vivedAPI = this.vivedAPI;
+            const jsonRequester = this.jsonRequester;
+            if (!getAuthToken || !vivedAPI || !jsonRequester) {
+                return Promise.reject();
+            }
+            return new Promise((resolve, reject) => {
+                getAuthToken()
+                    .then((token) => {
+                    const endpointURL = vivedAPI.getEndpointURL(`apps/${appID}/${version}`);
+                    endpointURL.searchParams.set("function_version", "2");
+                    const options = {
+                        method: "GET",
+                        headers: {
+                            Authorization: "Bearer " + token
+                        }
+                    };
+                    return jsonRequester(endpointURL, options);
+                })
+                    .then((resp) => {
+                    const app = resp.app;
+                    const appDTO = {
+                        interfaceVersion: app.appInterfaceVersion,
+                        assetFolderURL: app.baseAssetsUrl,
+                        entrypoints: [...app.files]
+                    };
+                    resolve(appDTO);
+                })
+                    .catch((e) => {
+                    reject(e);
+                    return;
+                });
+            });
+        };
+        this.appObjects.registerSingleton(this);
+    }
+    get jsonRequester() {
+        var _a;
+        return (_a = this.getCachedSingleton(JsonRequestUC_1.JsonRequestUC.type)) === null || _a === void 0 ? void 0 : _a.doRequest;
+    }
+    get getAuthToken() {
+        var _a;
+        return (_a = this.getCachedSingleton(SignedAuthTokenUC_1.SignedAuthTokenUC.type)) === null || _a === void 0 ? void 0 : _a.getUserAuthToken;
+    }
+    get vivedAPI() {
+        return this.getCachedSingleton(VivedAPIEntity_1.VivedAPIEntity.type);
+    }
+}

package/lib/Components/VivedAPI/UCs/GetAssetsForOwnerFromAPIUC.d.ts

@@ -0,0 +1,8 @@
+import { HostAppObject, HostAppObjectRepo, HostAppObjectUC } from '../../../HostAppObject';
+import { AssetDTO } from '../../Assets';
+export declare abstract class GetAssetsForOwnerFromAPIUC extends HostAppObjectUC {
+    static type: string;
+    abstract getAssets(ownerID: string): Promise<AssetDTO[]>;
+    static get(appObjects: HostAppObjectRepo): GetAssetsForOwnerFromAPIUC | undefined;
+}
+export declare function makeGetAssetsForOwnerFromAPIUC(appObject: HostAppObject): GetAssetsForOwnerFromAPIUC;