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

package/lib/portal/workflow/lifecycle.js

@@ -0,0 +1,616 @@
+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 _define_property(obj, key, value) {
+    if (key in obj) {
+        Object.defineProperty(obj, key, {
+            value: value,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        });
+    } else {
+        obj[key] = value;
+    }
+    return obj;
+}
+function _instanceof(left, right) {
+    if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
+        return !!right[Symbol.hasInstance](left);
+    } else {
+        return left instanceof right;
+    }
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+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 { randomUUID } from "node:crypto";
+import { runPublicationWorkflow } from "./execution.js";
+import { waitForIngestionSessionReady } from "./ingestion.js";
+import { logWorkflowInfo } from "./logging.js";
+import { hasResolvableReleaseMetadataUri, normalizePublicationBundle, validatePublicationBundle, withPublicationBundleIdentifiers } from "./state/bundle.js";
+import { normalizePublicationSession } from "./state/session.js";
+import { preparePublicationSource } from "./source/preparation.js";
+function normalizeWorkflowError(error) {
+    return _instanceof(error, Error) ? error : new Error(String(error));
+}
+function resolvePublicationSessionLookup(input) {
+    if (input.publicationSessionId) {
+        return {
+            publicationSessionId: input.publicationSessionId
+        };
+    }
+    if (!input.releaseId) {
+        throw new Error("releaseId is required when publicationSessionId is absent");
+    }
+    return {
+        releaseId: input.releaseId
+    };
+}
+function loadPublicationSession(client, input, options) {
+    return _async_to_generator(function() {
+        var _input_publicationSessionId, _input_existingSession, publicationSession, _tmp;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    logWorkflowInfo(options.logger, input.startMessage, {
+                        step: "session.load",
+                        status: "running",
+                        releaseId: input.releaseId,
+                        publicationSessionId: (_input_publicationSessionId = input.publicationSessionId) !== null && _input_publicationSessionId !== void 0 ? _input_publicationSessionId : undefined
+                    });
+                    if (!((_input_existingSession = input.existingSession) !== null && _input_existingSession !== void 0)) return [
+                        3,
+                        1
+                    ];
+                    _tmp = _input_existingSession;
+                    return [
+                        3,
+                        3
+                    ];
+                case 1:
+                    return [
+                        4,
+                        client.getPublicationSession(resolvePublicationSessionLookup({
+                            publicationSessionId: input.publicationSessionId,
+                            releaseId: input.releaseId
+                        }))
+                    ];
+                case 2:
+                    _tmp = normalizePublicationSession.apply(void 0, [
+                        _state.sent()
+                    ]);
+                    _state.label = 3;
+                case 3:
+                    publicationSession = _tmp;
+                    logWorkflowInfo(options.logger, input.completeMessage, {
+                        step: "session.load",
+                        status: "complete",
+                        releaseId: publicationSession.releaseId,
+                        publicationSessionId: publicationSession.id,
+                        stage: publicationSession.stage
+                    });
+                    return [
+                        2,
+                        publicationSession
+                    ];
+            }
+        });
+    })();
+}
+function loadPublicationBundle(client, input, options) {
+    return _async_to_generator(function() {
+        var _input_publicationSessionId, _input_ingestionSessionId, publicationBundle, _tmp;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    logWorkflowInfo(options.logger, "Loading publication bundle", {
+                        step: "bundle.load",
+                        status: "running",
+                        releaseId: input.releaseId
+                    });
+                    if (!(input.existingBundle && hasResolvableReleaseMetadataUri(input.existingBundle, input.existingSession))) return [
+                        3,
+                        1
+                    ];
+                    _tmp = input.existingBundle;
+                    return [
+                        3,
+                        3
+                    ];
+                case 1:
+                    return [
+                        4,
+                        client.getPublicationBundle({
+                            releaseId: input.releaseId
+                        })
+                    ];
+                case 2:
+                    _tmp = withPublicationBundleIdentifiers.apply(void 0, [
+                        normalizePublicationBundle.apply(void 0, [
+                            _state.sent()
+                        ]),
+                        {
+                            releaseId: input.releaseId,
+                            publicationSessionId: (_input_publicationSessionId = input.publicationSessionId) !== null && _input_publicationSessionId !== void 0 ? _input_publicationSessionId : null,
+                            ingestionSessionId: (_input_ingestionSessionId = input.ingestionSessionId) !== null && _input_ingestionSessionId !== void 0 ? _input_ingestionSessionId : null
+                        }
+                    ]);
+                    _state.label = 3;
+                case 3:
+                    publicationBundle = _tmp;
+                    validatePublicationBundle(publicationBundle);
+                    logWorkflowInfo(options.logger, "Publication bundle loaded", {
+                        step: "bundle.load",
+                        status: "complete",
+                        releaseId: input.releaseId,
+                        androidPackage: publicationBundle.release.androidPackage,
+                        versionName: publicationBundle.release.versionName
+                    });
+                    return [
+                        2,
+                        publicationBundle
+                    ];
+            }
+        });
+    })();
+}
+function recoverPublicationResult(client, releaseId, input, options) {
+    return _async_to_generator(function() {
+        var publicationSession, _publicationSession_ingestionSessionId, publicationBundle;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    logWorkflowInfo(options.logger, "Recovering final publication state", {
+                        step: "cleanup.recover",
+                        status: "running",
+                        releaseId: releaseId
+                    });
+                    return [
+                        4,
+                        client.getPublicationSession({
+                            releaseId: releaseId
+                        })
+                    ];
+                case 1:
+                    publicationSession = normalizePublicationSession.apply(void 0, [
+                        _state.sent()
+                    ]);
+                    return [
+                        4,
+                        client.getPublicationBundle({
+                            releaseId: releaseId
+                        })
+                    ];
+                case 2:
+                    publicationBundle = withPublicationBundleIdentifiers.apply(void 0, [
+                        normalizePublicationBundle.apply(void 0, [
+                            _state.sent()
+                        ]),
+                        {
+                            releaseId: releaseId,
+                            publicationSessionId: publicationSession.id,
+                            ingestionSessionId: (_publicationSession_ingestionSessionId = publicationSession.ingestionSessionId) !== null && _publicationSession_ingestionSessionId !== void 0 ? _publicationSession_ingestionSessionId : null
+                        }
+                    ]);
+                    logWorkflowInfo(options.logger, "Recovered final publication state", {
+                        step: "cleanup.recover",
+                        status: "complete",
+                        releaseId: releaseId,
+                        publicationSessionId: publicationSession.id,
+                        stage: publicationSession.stage
+                    });
+                    return [
+                        2,
+                        runPublicationWorkflow(client, publicationBundle, input.signer, input.attestationClient, publicationSession, options.logger)
+                    ];
+            }
+        });
+    })();
+}
+function cleanupFailedRelease(client, releaseId, error, options) {
+    return _async_to_generator(function() {
+        var _options_logger_warn, _options_logger, cleanupResult, message;
+        return _ts_generator(this, function(_state) {
+            switch(_state.label){
+                case 0:
+                    if (!client.cleanupRelease) {
+                        return [
+                            2,
+                            null
+                        ];
+                    }
+                    (_options_logger = options.logger) === null || _options_logger === void 0 ? void 0 : (_options_logger_warn = _options_logger.warn) === null || _options_logger_warn === void 0 ? void 0 : _options_logger_warn.call(_options_logger, "Rolling back failed publication release", {
+                        step: "cleanup.release",
+                        status: "running",
+                        releaseId: releaseId,
+                        error: error.message
+                    });
+                    return [
+                        4,
+                        client.cleanupRelease({
+                            releaseId: releaseId
+                        })
+                    ];
+                case 1:
+                    cleanupResult = _state.sent();
+                    message = cleanupResult.action === "deleted" ? "Failed publication release cleaned up" : "Publication already reached the submitted state; preserving release";
+                    logWorkflowInfo(options.logger, message, {
+                        step: "cleanup.release",
+                        status: "complete",
+                        releaseId: releaseId,
+                        action: cleanupResult.action
+                    });
+                    return [
+                        2,
+                        cleanupResult
+                    ];
+            }
+        });
+    })();
+}
+export var createPublicationWorkflow = function(client) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var _options_pollIntervalMs, _options_maxPollAttempts;
+    var pollOptions = {
+        pollIntervalMs: (_options_pollIntervalMs = options.pollIntervalMs) !== null && _options_pollIntervalMs !== void 0 ? _options_pollIntervalMs : 2500,
+        // Large APK ingestion can legitimately take tens of minutes once upload,
+        // managed-storage download, hashing, aapt2, and apksigner are included.
+        // Keep the default wait aligned with the portal queue headroom instead of
+        // failing after only ~5 minutes.
+        maxPollAttempts: (_options_maxPollAttempts = options.maxPollAttempts) !== null && _options_maxPollAttempts !== void 0 ? _options_maxPollAttempts : 1080
+    };
+    return {
+        startPublication: function startPublication(input) {
+            return _async_to_generator(function() {
+                var createdReleaseId, createdIngestionSessionId, _ingestionSession_bundle, _ingestionSession_id, _readySession_bundle, source, _input_idempotencyKey, ingestionSession, _ingestionSession_releaseId, _ref, readySession, _readySession_releaseId, _ref1, releaseId, readyPublicationSession, _readySession_publicationSessionId, readyPublicationBundle, _readySession_publicationSessionId1, publicationBundle, _readySession_publicationSessionId2, publicationSession, error, normalizedError, _failedIngestionSession_bundle, failedIngestionSession, _failedIngestionSession_releaseId, _ref2, e, cleanupResult, cleanupError, normalizedCleanupError;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            _state.trys.push([
+                                0,
+                                7,
+                                ,
+                                18
+                            ]);
+                            logWorkflowInfo(options.logger, "Preparing publication source", {
+                                step: "source.prepare",
+                                status: "running"
+                            });
+                            return [
+                                4,
+                                preparePublicationSource(client, input.source, options.logger)
+                            ];
+                        case 1:
+                            source = _state.sent();
+                            logWorkflowInfo(options.logger, "Creating ingestion session", {
+                                step: "ingestion.create",
+                                status: "running"
+                            });
+                            return [
+                                4,
+                                client.createIngestionSession(_object_spread({
+                                    source: source,
+                                    whatsNew: input.whatsNew,
+                                    idempotencyKey: (_input_idempotencyKey = input.idempotencyKey) !== null && _input_idempotencyKey !== void 0 ? _input_idempotencyKey : randomUUID()
+                                }, input.dappId ? {
+                                    dappId: input.dappId
+                                } : {}))
+                            ];
+                        case 2:
+                            ingestionSession = _state.sent();
+                            createdReleaseId = (_ref = (_ingestionSession_releaseId = ingestionSession.releaseId) !== null && _ingestionSession_releaseId !== void 0 ? _ingestionSession_releaseId : (_ingestionSession_bundle = ingestionSession.bundle) === null || _ingestionSession_bundle === void 0 ? void 0 : _ingestionSession_bundle.releaseId) !== null && _ref !== void 0 ? _ref : undefined;
+                            createdIngestionSessionId = (_ingestionSession_id = ingestionSession.id) === null || _ingestionSession_id === void 0 ? void 0 : _ingestionSession_id.trim();
+                            if (!createdIngestionSessionId) {
+                                throw new Error("Portal createIngestionSession did not return an ingestion session id");
+                            }
+                            logWorkflowInfo(options.logger, "Ingestion session created", {
+                                step: "ingestion.create",
+                                status: "complete",
+                                ingestionSessionId: createdIngestionSessionId,
+                                releaseId: createdReleaseId
+                            });
+                            return [
+                                4,
+                                waitForIngestionSessionReady(client, createdIngestionSessionId, pollOptions, options.logger)
+                            ];
+                        case 3:
+                            readySession = _state.sent();
+                            releaseId = (_ref1 = (_readySession_releaseId = readySession.releaseId) !== null && _readySession_releaseId !== void 0 ? _readySession_releaseId : (_readySession_bundle = readySession.bundle) === null || _readySession_bundle === void 0 ? void 0 : _readySession_bundle.releaseId) !== null && _ref1 !== void 0 ? _ref1 : undefined;
+                            if (!releaseId) {
+                                throw new Error("Publication ingestion completed without a release identifier");
+                            }
+                            createdReleaseId = releaseId;
+                            readyPublicationSession = readySession.publicationSession ? normalizePublicationSession(readySession.publicationSession) : undefined;
+                            readyPublicationBundle = readySession.bundle ? withPublicationBundleIdentifiers(normalizePublicationBundle(readySession.bundle), {
+                                releaseId: releaseId,
+                                publicationSessionId: (_readySession_publicationSessionId = readySession.publicationSessionId) !== null && _readySession_publicationSessionId !== void 0 ? _readySession_publicationSessionId : null,
+                                ingestionSessionId: readySession.id
+                            }) : null;
+                            return [
+                                4,
+                                loadPublicationBundle(client, {
+                                    releaseId: releaseId,
+                                    publicationSessionId: (_readySession_publicationSessionId1 = readySession.publicationSessionId) !== null && _readySession_publicationSessionId1 !== void 0 ? _readySession_publicationSessionId1 : null,
+                                    ingestionSessionId: readySession.id,
+                                    existingBundle: readyPublicationBundle,
+                                    existingSession: readyPublicationSession
+                                }, options)
+                            ];
+                        case 4:
+                            publicationBundle = _state.sent();
+                            return [
+                                4,
+                                loadPublicationSession(client, {
+                                    releaseId: releaseId,
+                                    publicationSessionId: (_readySession_publicationSessionId2 = readySession.publicationSessionId) !== null && _readySession_publicationSessionId2 !== void 0 ? _readySession_publicationSessionId2 : null,
+                                    existingSession: readyPublicationSession,
+                                    startMessage: "Loading publication session",
+                                    completeMessage: "Publication session loaded"
+                                }, options)
+                            ];
+                        case 5:
+                            publicationSession = _state.sent();
+                            return [
+                                4,
+                                runPublicationWorkflow(client, publicationBundle, input.signer, input.attestationClient, publicationSession, options.logger)
+                            ];
+                        case 6:
+                            return [
+                                2,
+                                _state.sent()
+                            ];
+                        case 7:
+                            error = _state.sent();
+                            normalizedError = normalizeWorkflowError(error);
+                            if (!(!createdReleaseId && createdIngestionSessionId)) return [
+                                3,
+                                11
+                            ];
+                            _state.label = 8;
+                        case 8:
+                            _state.trys.push([
+                                8,
+                                10,
+                                ,
+                                11
+                            ]);
+                            return [
+                                4,
+                                client.getIngestionSession({
+                                    sessionId: createdIngestionSessionId,
+                                    ingestionSessionId: createdIngestionSessionId
+                                })
+                            ];
+                        case 9:
+                            failedIngestionSession = _state.sent();
+                            createdReleaseId = (_ref2 = (_failedIngestionSession_releaseId = failedIngestionSession.releaseId) !== null && _failedIngestionSession_releaseId !== void 0 ? _failedIngestionSession_releaseId : (_failedIngestionSession_bundle = failedIngestionSession.bundle) === null || _failedIngestionSession_bundle === void 0 ? void 0 : _failedIngestionSession_bundle.releaseId) !== null && _ref2 !== void 0 ? _ref2 : undefined;
+                            return [
+                                3,
+                                11
+                            ];
+                        case 10:
+                            e = _state.sent();
+                            return [
+                                3,
+                                11
+                            ];
+                        case 11:
+                            if (!createdReleaseId) {
+                                throw normalizedError;
+                            }
+                            _state.label = 12;
+                        case 12:
+                            _state.trys.push([
+                                12,
+                                16,
+                                ,
+                                17
+                            ]);
+                            return [
+                                4,
+                                cleanupFailedRelease(client, createdReleaseId, normalizedError, options)
+                            ];
+                        case 13:
+                            cleanupResult = _state.sent();
+                            if (!((cleanupResult === null || cleanupResult === void 0 ? void 0 : cleanupResult.action) === "preservedSubmitted")) return [
+                                3,
+                                15
+                            ];
+                            return [
+                                4,
+                                recoverPublicationResult(client, createdReleaseId, input, options)
+                            ];
+                        case 14:
+                            return [
+                                2,
+                                _state.sent()
+                            ];
+                        case 15:
+                            return [
+                                3,
+                                17
+                            ];
+                        case 16:
+                            cleanupError = _state.sent();
+                            normalizedCleanupError = normalizeWorkflowError(cleanupError);
+                            throw new Error("".concat(normalizedError.message, " Cleanup also failed for release ").concat(createdReleaseId, ": ").concat(normalizedCleanupError.message));
+                        case 17:
+                            throw normalizedError;
+                        case 18:
+                            return [
+                                2
+                            ];
+                    }
+                });
+            })();
+        },
+        resumePublication: function resumePublication(input) {
+            return _async_to_generator(function() {
+                var _input_publicationSessionId, publicationSession, _publicationSession_ingestionSessionId, publicationBundle;
+                return _ts_generator(this, function(_state) {
+                    switch(_state.label){
+                        case 0:
+                            if (!input.publicationSessionId && !input.releaseId) {
+                                throw new Error("Publication session id or release id is required to resume a publication");
+                            }
+                            return [
+                                4,
+                                loadPublicationSession(client, {
+                                    publicationSessionId: (_input_publicationSessionId = input.publicationSessionId) !== null && _input_publicationSessionId !== void 0 ? _input_publicationSessionId : null,
+                                    releaseId: input.releaseId,
+                                    startMessage: "Loading existing publication session",
+                                    completeMessage: "Existing publication session loaded"
+                                }, options)
+                            ];
+                        case 1:
+                            publicationSession = _state.sent();
+                            return [
+                                4,
+                                loadPublicationBundle(client, {
+                                    releaseId: publicationSession.releaseId,
+                                    publicationSessionId: publicationSession.id,
+                                    ingestionSessionId: (_publicationSession_ingestionSessionId = publicationSession.ingestionSessionId) !== null && _publicationSession_ingestionSessionId !== void 0 ? _publicationSession_ingestionSessionId : null
+                                }, options)
+                            ];
+                        case 2:
+                            publicationBundle = _state.sent();
+                            return [
+                                2,
+                                runPublicationWorkflow(client, publicationBundle, input.signer, input.attestationClient, publicationSession, options.logger)
+                            ];
+                    }
+                });
+            })();
+        }
+    };
+};

package/lib/portal/workflow/logging.js

@@ -0,0 +1,8 @@
+export function logWorkflowInfo(logger, message, metadata) {
+    var _logger_info;
+    logger === null || logger === void 0 ? void 0 : (_logger_info = logger.info) === null || _logger_info === void 0 ? void 0 : _logger_info.call(logger, message, metadata);
+}
+export function logWorkflowDebug(logger, message, metadata) {
+    var _logger_debug;
+    logger === null || logger === void 0 ? void 0 : (_logger_debug = logger.debug) === null || _logger_debug === void 0 ? void 0 : _logger_debug.call(logger, message, metadata);
+}