@minka/nx-remote-cache/dist/index.js

This repository provides an NX runner that utilizes a Google Cloud Platform (GCP) bucket as distributed cache storage.

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
    var ownKeys = function(o) {
        ownKeys = Object.getOwnPropertyNames || function (o) {
            var ar = [];
            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
            return ar;
        };
        return ownKeys(o);
    };
    return function (mod) {
        if (mod && mod.__esModule) return mod;
        var result = {};
        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
        __setModuleDefault(result, mod);
        return result;
    };
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.createStorageInterface = void 0;
const _ = __importStar(require("lodash"));
const storage_1 = require("@google-cloud/storage");
const nx_remotecache_custom_1 = require("nx-remotecache-custom");
const createStorageInterface = async (options) => {
    // initialize environment variables from dotfile
    (0, nx_remotecache_custom_1.initEnv)(options);
    const storage = new GCPStorage(options);
    return {
        name: storage.name,
        fileExists: (filename) => storage.fileExists(filename),
        storeFile: (filename, data) => storage.storeFile(filename, data),
        retrieveFile: (filename) => storage.retrieveFile(filename),
    };
};
exports.createStorageInterface = createStorageInterface;
exports.default = (0, nx_remotecache_custom_1.createCustomRunner)(createStorageInterface);
class GCPStorage {
    constructor(options) {
        this.name = "GCP Storage";
        const projectId = options.project_id || process.env.NXCACHE_GOOGLE_STORAGE_PROJECT_ID;
        const bucketName = options.bucket || process.env.NXCACHE_GOOGLE_STORAGE_BUCKET;
        if (!bucketName || _.isEmpty(bucketName)) {
            throw new Error("No bucket specified - specify either through 'options.bucketName' in nx.json or env var NXCACHE_GOOGLE_STORAGE_BUCKET");
        }
        if (_.isEmpty(projectId) || _.isEmpty(projectId)) {
            throw new Error("No project ID specified - specify either through 'options.project_id' in nx.json or env var NXCACHE_GOOGLE_STORAGE_PROJECT_ID");
        }
        const storage = new storage_1.Storage({
            projectId,
        });
        this.bucket = storage.bucket(bucketName);
    }
    async fileExists(filename) {
        try {
            const file = this.bucket.file(filename);
            const result = await file.exists();
            return result[0];
        }
        catch (e) {
            const message = `[ERROR] Could not check if file ${filename} exists in GCP storage - cache may not be used even if it exists:\n`;
            console.error(message, e.message, e.stack);
            return false;
        }
    }
    async retrieveFile(filename) {
        try {
            const file = this.bucket.file(filename);
            return file.createReadStream();
        }
        catch (e) {
            const message = `[ERROR] Could not retrieve file ${filename} from GCP storage`;
            const errorMessage = e.message || message;
            console.error(message, e.message, e.stack);
            throw new Error(errorMessage);
        }
    }
    storeFile(filename, data) {
        try {
            const file = this.bucket.file(filename);
            return new Promise((resolve) => {
                const stream = file.createWriteStream({ resumable: false });
                data.pipe(stream);
                stream.on("finish", () => resolve());
            });
        }
        catch (e) {
            const message = `[ERROR] Could not store file ${filename} to GCP storage`;
            const errorMessage = e.message || message;
            console.error(message, e.message, e.stack);
            throw new Error(errorMessage);
        }
    }
}