@itwin/object-storage-google/lib/server/wrappers/StorageControlClientWrapper.js

Object storage implementation using Google Cloud Storage

"use strict";
/*---------------------------------------------------------------------------------------------
 * Copyright (c) Bentley Systems, Incorporated. All rights reserved.
 * See LICENSE.md in the project root for license terms and full copyright notice.
 *--------------------------------------------------------------------------------------------*/
Object.defineProperty(exports, "__esModule", { value: true });
exports.StorageControlClientWrapper = void 0;
exports.isGoogleError = isGoogleError;
const storage_control_1 = require("@google-cloud/storage-control");
const google_auth_library_1 = require("google-auth-library");
const common_1 = require("../../common");
const Helpers_1 = require("./Helpers");
function isGoogleError(error) {
    return error instanceof Error && error.code !== undefined;
}
class StorageControlClientWrapper {
    _config;
    _client;
    constructor(_config) {
        this._config = _config;
        this._client = new storage_control_1.StorageControlClient({
            projectId: this._config.projectId,
        });
    }
    async createManagedFolder(folderName) {
        const parent = this.bucketPath;
        await this._client.createManagedFolder({
            parent,
            managedFolderId: folderName,
        });
    }
    async deleteManagedFolder(folderName) {
        const managedFolder = this.managedFolderPath(folderName);
        try {
            await this._client.deleteManagedFolder({
                name: managedFolder,
            });
        }
        catch (error) {
            if (isGoogleError(error) && error.code != 5) {
                throw error;
            }
        }
    }
    async getManagedFoldersNextPage(options) {
        const parent = this.bucketPath;
        const [folders, _, response] = await this._client.listManagedFolders({
            parent,
            pageSize: options.maxPageSize,
            pageToken: options.continuationToken,
        }, { autoPaginate: false });
        const directories = folders.map((entry) => {
            return {
                baseDirectory: entry.name?.split("/").slice(5, -1).join("/"),
            };
        }) ?? [];
        const continuationToken = response?.nextPageToken;
        const page = {
            entities: directories,
            next: !continuationToken
                ? undefined
                : () => this.getManagedFoldersNextPage({
                    maxPageSize: options.maxPageSize,
                    continuationToken: continuationToken,
                }),
        };
        return page;
    }
    async getManagedFolders() {
        const parent = this._client.bucketPath("_", this._config.bucketName);
        const [folders, _1, _2] = await this._client.listManagedFolders({
            parent,
        });
        const directories = folders.map((entry) => ({ baseDirectory: entry.name })) ?? [];
        return directories;
    }
    async managedFolderExists(folderName) {
        const managedFolder = this.managedFolderPath(folderName);
        try {
            await this._client.getManagedFolder({
                name: managedFolder,
            });
            return true;
        }
        catch (error) {
            if (isGoogleError(error) && error.code == 5) {
                return false;
            }
            throw error;
        }
    }
    async createAccessToken(action, folderName) {
        const cab = {
            accessBoundary: {
                accessBoundaryRules: [
                    {
                        availableResource: this.bucketUri,
                        availablePermissions: [(0, Helpers_1.roleFromConfigType)(action)],
                        availabilityCondition: {
                            expression: `resource.name.startsWith('${this.bucketPath}/objects/${folderName}') || ` +
                                `api.getAttribute('storage.googleapis.com/objectListPrefix', '')` +
                                `.startsWith('${folderName}/')`,
                        },
                    },
                ],
            },
        };
        const googleAuth = new google_auth_library_1.GoogleAuth({
            scopes: "https://www.googleapis.com/auth/cloud-platform",
            projectId: this._config.projectId,
        });
        const client = await googleAuth.getClient();
        const downscopedClient = new google_auth_library_1.DownscopedClient(client, cab);
        const { token, expirationTime } = await downscopedClient.getAccessToken();
        return {
            baseUrl: this.bucketUri,
            authentication: `Bearer ${token}`,
            expiration: new Date(expirationTime),
            bucketName: this._config.bucketName,
            storageType: common_1.Constants.storageType,
        };
    }
    managedFolderPath(folderName) {
        return this._client.managedFolderPath("_", this._config.bucketName, folderName);
    }
    get bucketPath() {
        return this._client.bucketPath("_", this._config.bucketName);
    }
    get bucketUri() {
        return `//storage.googleapis.com/${this.bucketPath}`;
    }
    async releaseResources() {
        await this._client.close();
    }
}
exports.StorageControlClientWrapper = StorageControlClientWrapper;
//# sourceMappingURL=StorageControlClientWrapper.js.map