@mablhq/mabl-cli 1.55.2 → 1.56.2

package/util/CloudStorageWriter.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const storage_1 = require("@google-cloud/storage");
+const IdentifierUtil_1 = require("./IdentifierUtil");
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const MAX_PUT_ATTEMPTS = 3;
+const AUTO_COMPRESS_MIME_TYPES = new Set([
+    'application/json',
+    'text/plain',
+]);
+class CloudStorageWriter {
+    constructor(projectId, workspaceId) {
+        this.bucket = new storage_1.Storage().bucket(`${projectId}-workspace-${(0, IdentifierUtil_1.toCloudSafeId)(workspaceId)}`);
+    }
+    bucketName() {
+        return this.bucket.name;
+    }
+    async write(path, contentType, data) {
+        let attempt = 0;
+        while (attempt++ < MAX_PUT_ATTEMPTS) {
+            try {
+                return await this.writeOnce(path, contentType, data);
+            }
+            catch (error) {
+                loggingProvider_1.logger.info(`Error writing file to GCS at ${path} (attempt ${attempt} of ${MAX_PUT_ATTEMPTS})`, error);
+                if (attempt === MAX_PUT_ATTEMPTS) {
+                    throw error;
+                }
+            }
+        }
+    }
+    writeOnce(path, contentType, data) {
+        return this.bucket.file(path).save(data, {
+            contentType,
+            metadata: {
+                'Content-Type': getNowIsoTimestamp(),
+            },
+            gzip: AUTO_COMPRESS_MIME_TYPES.has(contentType.toLowerCase()),
+        });
+    }
+}
+exports.default = CloudStorageWriter;
+function getNowIsoTimestamp() {
+    return new Date().toISOString();
+}

package/util/IdentifierUtil.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCloudSafeId = void 0;
+const legacyUuidPattern = /^[a-fA-F0-9-]{36}$/;
+const untypedUidPattern = /^[a-zA-Z0-9_-]+$/;
+const typedUidPattern = /^(?<id>[a-zA-Z0-9_-]{22})-(?<type>[a-z]+)$/;
+const idTypes = {
+    uuid: 1,
+    untypedUid: 2,
+    typedUid: 3,
+};
+function isLegacyUuid(id) {
+    return !!id.match(legacyUuidPattern);
+}
+function isUntypedUid(id) {
+    return !!id.match(untypedUidPattern);
+}
+function isTypedUid(id) {
+    return !!id.match(typedUidPattern);
+}
+function legacyUuidToHex(id) {
+    const idTypeBuffer = Buffer.alloc(1, idTypes.uuid);
+    const idBuffer = Buffer.from(id.toLowerCase().replace(/-/g, ''), 'hex');
+    return Buffer.concat([idTypeBuffer, idBuffer]).toString('hex');
+}
+function untypedUidToHex(id) {
+    const idTypeBuffer = Buffer.alloc(1, idTypes.untypedUid);
+    const idBuffer = Buffer.from(id.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+    return Buffer.concat([idTypeBuffer, idBuffer]).toString('hex');
+}
+function typedUidToHex(typedUid) {
+    const { id, type } = typedUid.match(typedUidPattern)
+        .groups;
+    const idTypeBuffer = Buffer.alloc(1, idTypes.typedUid);
+    const idBuffer = Buffer.from(id.replace(/-/g, '+').replace(/_/g, '/'), 'base64');
+    const typeBuffer = Buffer.from(type, 'utf8');
+    return Buffer.concat([idTypeBuffer, idBuffer, typeBuffer]).toString('hex');
+}
+function hexToBase36(hex) {
+    return BigInt(`0x${hex}`).toString(36);
+}
+function toCloudSafeId(id) {
+    if (!id) {
+        throw new Error('id is required');
+    }
+    if (isLegacyUuid(id)) {
+        return hexToBase36(legacyUuidToHex(id));
+    }
+    if (isTypedUid(id)) {
+        return hexToBase36(typedUidToHex(id));
+    }
+    if (isUntypedUid(id)) {
+        return hexToBase36(untypedUidToHex(id));
+    }
+    throw new Error(`Not a valid ID: [${id}]`);
+}
+exports.toCloudSafeId = toCloudSafeId;

package/util/TestOutputWriter.js

@@ -0,0 +1,67 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const CloudStorageWriter_1 = __importDefault(require("./CloudStorageWriter"));
+const murmurhash = __importStar(require("murmurhash"));
+const loggingProvider_1 = require("../providers/logging/loggingProvider");
+const HASH_PREFIX_LENGTH = 4;
+const EXECUTION_OUTPUT_PATH_PREFIX = 'execution-output';
+const MAX_PATH_LENGTH = 1024;
+class TestOutputWriterImpl {
+    constructor(projectId, workspaceId, applicationId, planId, planRunId, testRunId) {
+        this.storageWriter = new CloudStorageWriter_1.default(projectId, workspaceId);
+        this.applicationId = applicationId;
+        this.planId = planId;
+        this.planRunId = planRunId;
+        this.testRunId = testRunId;
+    }
+    async writeObjectAsJson(name, data) {
+        return this.write(name, 'application/json', Buffer.from(JSON.stringify(data)));
+    }
+    async write(name, contentType, data) {
+        const path = this.nameToFullPath(name);
+        await this.storageWriter.write(path, contentType, data);
+        return `${this.storageWriter.bucketName()}/${path}`;
+    }
+    nameToFullPath(name) {
+        const directoryPath = `${this.applicationId}/${this.planId}/${this.planRunId}/${this.testRunId}`;
+        const hash = this.generateHash(`${directoryPath}/${name}`);
+        const fullPath = `${EXECUTION_OUTPUT_PATH_PREFIX}/${hash}/${directoryPath}/${name}`;
+        if (fullPath.length <= MAX_PATH_LENGTH) {
+            return fullPath;
+        }
+        loggingProvider_1.logger.info(`WARNING: Truncating path longer than ${MAX_PATH_LENGTH}: ${fullPath}`);
+        const overage = fullPath.length - MAX_PATH_LENGTH;
+        const truncatedName = name.substring(overage);
+        return `${EXECUTION_OUTPUT_PATH_PREFIX}/${hash}/${directoryPath}/${truncatedName}`;
+    }
+    generateHash(value) {
+        return murmurhash.v3(value).toString(36).substring(0, HASH_PREFIX_LENGTH);
+    }
+}
+exports.default = TestOutputWriterImpl;