@solana-mobile/dapp-store-publishing-tools 0.16.0 → 1.0.0

package/lib/portal/workflow/source/files.js

@@ -0,0 +1,304 @@
+function _async_iterator(iterable) {
+    var method, async, sync, retry = 2;
+    for("undefined" != typeof Symbol && (async = Symbol.asyncIterator, sync = Symbol.iterator); retry--;){
+        if (async && null != (method = iterable[async])) return method.call(iterable);
+        if (sync && null != (method = iterable[sync])) return new AsyncFromSyncIterator(method.call(iterable));
+        async = "@@asyncIterator", sync = "@@iterator";
+    }
+    throw new TypeError("Object is not async iterable");
+}
+function AsyncFromSyncIterator(s) {
+    function AsyncFromSyncIteratorContinuation(r) {
+        if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+        var done = r.done;
+        return Promise.resolve(r.value).then(function(value) {
+            return {
+                value: value,
+                done: done
+            };
+        });
+    }
+    return AsyncFromSyncIterator = function(s) {
+        this.s = s, this.n = s.next;
+    }, AsyncFromSyncIterator.prototype = {
+        s: null,
+        n: null,
+        next: function() {
+            return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+        },
+        return: function(value) {
+            var ret = this.s.return;
+            return void 0 === ret ? Promise.resolve({
+                value: value,
+                done: !0
+            }) : AsyncFromSyncIteratorContinuation(ret.apply(this.s, arguments));
+        },
+        throw: function(value) {
+            var thr = this.s.return;
+            return void 0 === thr ? Promise.reject(value) : AsyncFromSyncIteratorContinuation(thr.apply(this.s, arguments));
+        }
+    }, new AsyncFromSyncIterator(s);
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { createHash } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { basename } from "node:path";
+export function ensureApkFileName(fileName) {
+    return /\.apk$/i.test(fileName) ? fileName : "".concat(fileName, ".apk");
+}
+export function inferFileNameFromUrl(url) {
+    try {
+        var pathname = new URL(url).pathname;
+        var fileName = basename(pathname);
+        return fileName.length > 0 ? fileName : "release.apk";
+    } catch (e) {
+        return "release.apk";
+    }
+}
+export function normalizeLocalFileAccessError(filePath, error) {
+    var code = error && (typeof error === "undefined" ? "undefined" : _type_of(error)) === "object" && "code" in error ? String(error.code || "") : "";
+    if (code === "EPERM" || code === "EACCES") {
+        return new Error("Cannot read local APK at ".concat(filePath, ". macOS denied access to this location (").concat(code, "). Move the APK out of Downloads into your workspace or another accessible folder, or grant this app Full Disk Access, then retry."));
+    }
+    return _instanceof(error, Error) ? error : new Error(String(error));
+}
+export function hashFileSha256(filePath) {
+    return _async_to_generator(function() {
+        var hash, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, _value, chunk, err, error;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    hash = createHash("sha256");
+                    _state.label = 1;
+                case 1:
+                    _state.trys.push([
+                        1,
+                        14,
+                        ,
+                        15
+                    ]);
+                    _iteratorAbruptCompletion = false, _didIteratorError = false;
+                    _state.label = 2;
+                case 2:
+                    _state.trys.push([
+                        2,
+                        7,
+                        8,
+                        13
+                    ]);
+                    _iterator = _async_iterator(createReadStream(filePath));
+                    _state.label = 3;
+                case 3:
+                    return [
+                        4,
+                        _iterator.next()
+                    ];
+                case 4:
+                    if (!(_iteratorAbruptCompletion = !(_step = _state.sent()).done)) return [
+                        3,
+                        6
+                    ];
+                    _value = _step.value;
+                    chunk = _value;
+                    hash.update(chunk);
+                    _state.label = 5;
+                case 5:
+                    _iteratorAbruptCompletion = false;
+                    return [
+                        3,
+                        3
+                    ];
+                case 6:
+                    return [
+                        3,
+                        13
+                    ];
+                case 7:
+                    err = _state.sent();
+                    _didIteratorError = true;
+                    _iteratorError = err;
+                    return [
+                        3,
+                        13
+                    ];
+                case 8:
+                    _state.trys.push([
+                        8,
+                        ,
+                        11,
+                        12
+                    ]);
+                    if (!(_iteratorAbruptCompletion && _iterator.return != null)) return [
+                        3,
+                        10
+                    ];
+                    return [
+                        4,
+                        _iterator.return()
+                    ];
+                case 9:
+                    _state.sent();
+                    _state.label = 10;
+                case 10:
+                    return [
+                        3,
+                        12
+                    ];
+                case 11:
+                    if (_didIteratorError) {
+                        throw _iteratorError;
+                    }
+                    return [
+                        7
+                    ];
+                case 12:
+                    return [
+                        7
+                    ];
+                case 13:
+                    return [
+                        3,
+                        15
+                    ];
+                case 14:
+                    error = _state.sent();
+                    throw normalizeLocalFileAccessError(filePath, error);
+                case 15:
+                    return [
+                        2,
+                        hash.digest("hex")
+                    ];
+            }
+        });
+    })();
+}

package/lib/portal/workflow/source/preparation.js

@@ -0,0 +1,318 @@
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() {
+        return this;
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { basename } from "node:path";
+import { Transform } from "node:stream";
+import { logWorkflowDebug, logWorkflowInfo } from "../logging.js";
+import { ensureApkFileName, hashFileSha256, inferFileNameFromUrl, normalizeLocalFileAccessError } from "./files.js";
+var DEFAULT_APK_CONTENT_TYPE = "application/vnd.android.package-archive";
+function uploadLocalApkToPortal(client, source, logger) {
+    return _async_to_generator(function() {
+        var createUploadTarget, fileStat, _source_mimeType, contentType, fileHash, fileName, uploadTarget, totalBytes, uploadedBytes, lastLoggedBytes, lastLoggedAt, emitUploadProgress, uploadBody, uploadResponse;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    createUploadTarget = client.createUploadTarget;
+                    if (!createUploadTarget) {
+                        throw new Error("Local apk-file sources require a createUploadTarget client method");
+                    }
+                    return [
+                        4,
+                        stat(source.filePath).catch(function(error) {
+                            throw normalizeLocalFileAccessError(source.filePath, error);
+                        })
+                    ];
+                case 1:
+                    fileStat = _state.sent();
+                    contentType = (_source_mimeType = source.mimeType) !== null && _source_mimeType !== void 0 ? _source_mimeType : DEFAULT_APK_CONTENT_TYPE;
+                    return [
+                        4,
+                        hashFileSha256(source.filePath)
+                    ];
+                case 2:
+                    fileHash = _state.sent();
+                    fileName = ensureApkFileName(source.fileName || basename(source.filePath));
+                    logWorkflowInfo(logger, "Uploading APK to portal storage", {
+                        step: "source.upload",
+                        status: "running",
+                        fileName: fileName,
+                        filePath: source.filePath,
+                        fileSize: fileStat.size
+                    });
+                    return [
+                        4,
+                        createUploadTarget({
+                            fileHash: fileHash,
+                            fileExtension: "apk",
+                            contentType: contentType
+                        })
+                    ];
+                case 3:
+                    uploadTarget = _state.sent();
+                    totalBytes = fileStat.size;
+                    uploadedBytes = 0;
+                    lastLoggedBytes = 0;
+                    lastLoggedAt = 0;
+                    emitUploadProgress = function() {
+                        var force = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : false;
+                        var now = Date.now();
+                        var progress = totalBytes > 0 ? uploadedBytes / totalBytes : 1;
+                        var byteDelta = uploadedBytes - lastLoggedBytes;
+                        var minByteDelta = Math.max(256 * 1024, Math.floor(totalBytes * 0.01));
+                        var shouldLog = force || uploadedBytes >= totalBytes || now - lastLoggedAt >= 250 || byteDelta >= minByteDelta;
+                        if (!shouldLog) {
+                            return;
+                        }
+                        lastLoggedAt = now;
+                        lastLoggedBytes = uploadedBytes;
+                        logWorkflowDebug(logger, "Uploading APK to portal storage", {
+                            step: "source.upload",
+                            status: "running",
+                            fileName: fileName,
+                            filePath: source.filePath,
+                            fileSize: totalBytes,
+                            bytesUploaded: uploadedBytes,
+                            bytesTotal: totalBytes,
+                            stepProgress: progress
+                        });
+                    };
+                    uploadBody = createReadStream(source.filePath).pipe(new Transform({
+                        transform: function transform(chunk, _encoding, callback) {
+                            uploadedBytes += chunk.length;
+                            emitUploadProgress();
+                            callback(null, chunk);
+                        }
+                    }));
+                    return [
+                        4,
+                        fetch(uploadTarget.uploadUrl, {
+                            method: "PUT",
+                            headers: {
+                                "content-type": contentType,
+                                "content-length": String(totalBytes)
+                            },
+                            body: uploadBody,
+                            duplex: "half"
+                        })
+                    ];
+                case 4:
+                    uploadResponse = _state.sent();
+                    if (!uploadResponse.ok) {
+                        throw new Error("Failed to upload APK to portal storage: ".concat(uploadResponse.status, " ").concat(uploadResponse.statusText));
+                    }
+                    uploadedBytes = totalBytes;
+                    emitUploadProgress(true);
+                    logWorkflowInfo(logger, "APK uploaded to portal storage", {
+                        step: "source.upload",
+                        status: "complete",
+                        fileName: fileName,
+                        publicUrl: uploadTarget.publicUrl
+                    });
+                    return [
+                        2,
+                        {
+                            kind: "portalUpload",
+                            releaseFileUrl: uploadTarget.publicUrl,
+                            releaseFileName: fileName,
+                            releaseFileSize: fileStat.size,
+                            releaseFileHash: fileHash,
+                            contentType: contentType
+                        }
+                    ];
+            }
+        });
+    })();
+}
+export function preparePublicationSource(client, source, logger) {
+    return _async_to_generator(function() {
+        var _source_releaseFileName, _source_canonicalUrl, _source_fileName, _source_canonicalUrl1, _source_canonicalUrl2, _source_canonicalUrl3, _source_fileName1, exhaustiveCheck;
+        return _ts_generator(this, function(_state) {
+            switch(source.kind){
+                case "portalUpload":
+                    logWorkflowInfo(logger, "Using portal-hosted APK source", {
+                        step: "source.ready",
+                        status: "complete",
+                        fileName: source.releaseFileName
+                    });
+                    return [
+                        2,
+                        source
+                    ];
+                case "externalUrl":
+                    ;
+                    logWorkflowInfo(logger, "Using external APK URL", {
+                        step: "source.ready",
+                        status: "complete",
+                        fileName: (_source_releaseFileName = source.releaseFileName) !== null && _source_releaseFileName !== void 0 ? _source_releaseFileName : inferFileNameFromUrl(source.apkUrl),
+                        apkUrl: source.apkUrl
+                    });
+                    return [
+                        2,
+                        source
+                    ];
+                case "existingRelease":
+                    logWorkflowInfo(logger, "Using an existing release as the source", {
+                        step: "source.ready",
+                        status: "complete",
+                        sourceReleaseId: source.sourceReleaseId
+                    });
+                    return [
+                        2,
+                        source
+                    ];
+                case "apk-url":
+                    ;
+                    logWorkflowInfo(logger, "Preparing external APK URL", {
+                        step: "source.ready",
+                        status: "running",
+                        fileName: (_source_fileName = source.fileName) !== null && _source_fileName !== void 0 ? _source_fileName : inferFileNameFromUrl((_source_canonicalUrl = source.canonicalUrl) !== null && _source_canonicalUrl !== void 0 ? _source_canonicalUrl : source.url),
+                        apkUrl: (_source_canonicalUrl1 = source.canonicalUrl) !== null && _source_canonicalUrl1 !== void 0 ? _source_canonicalUrl1 : source.url
+                    });
+                    ;
+                    return [
+                        2,
+                        {
+                            kind: "externalUrl",
+                            apkUrl: (_source_canonicalUrl2 = source.canonicalUrl) !== null && _source_canonicalUrl2 !== void 0 ? _source_canonicalUrl2 : source.url,
+                            releaseFileName: (_source_fileName1 = source.fileName) !== null && _source_fileName1 !== void 0 ? _source_fileName1 : inferFileNameFromUrl((_source_canonicalUrl3 = source.canonicalUrl) !== null && _source_canonicalUrl3 !== void 0 ? _source_canonicalUrl3 : source.url)
+                        }
+                    ];
+                case "apk-file":
+                    return [
+                        2,
+                        uploadLocalApkToPortal(client, source, logger)
+                    ];
+                default:
+                    {
+                        exhaustiveCheck = source;
+                        return [
+                            2,
+                            exhaustiveCheck
+                        ];
+                    }
+            }
+            return [
+                2
+            ];
+        });
+    })();
+}