@solana-mobile/dapp-store-cli 0.15.0 → 0.16.1

package/lib/publication/__tests__/PublicationProgressReporter.test.js

@@ -0,0 +1,174 @@
+import { expect, jest, test } from '@jest/globals';
+import { Writable } from 'node:stream';
+import { createPublicationProgressReporter } from '../PublicationProgressReporter';
+function createTestStream() {
+    var output = [];
+    var stream = new Writable({
+        write: function write(chunk, _encoding, callback) {
+            output.push(String(chunk));
+            callback();
+        }
+    });
+    stream.isTTY = false;
+    stream.columns = 120;
+    stream.output = output;
+    return stream;
+}
+test('local file upload progress materially advances the bar', function() {
+    var logSpy = jest.spyOn(console, 'log').mockImplementation(function() {});
+    var stream = createTestStream();
+    try {
+        var reporter = createPublicationProgressReporter({
+            title: 'Publishing version',
+            mode: 'new-version',
+            stream: stream
+        });
+        reporter.start({
+            metadata: {
+                sourceKind: 'apk-file',
+                fileName: 'app-release.apk'
+            }
+        });
+        reporter.logger.debug('Uploading APK to portal storage', {
+            step: 'source.upload',
+            status: 'running',
+            fileName: 'app-release.apk',
+            fileSize: 100,
+            bytesUploaded: 50,
+            bytesTotal: 100,
+            stepProgress: 0.5
+        });
+        var lines = reporter.buildLines();
+        expect(reporter.getProgressPercent()).toBeGreaterThan(0.2);
+        expect(lines[1]).toContain('23%');
+        expect(lines).toContain('Upload: 50 B / 100 B (50%)');
+    } finally{
+        logSpy.mockRestore();
+    }
+});
+test('ingestion status updates continue advancing overall progress', function() {
+    var logSpy = jest.spyOn(console, 'log').mockImplementation(function() {});
+    var stream = createTestStream();
+    try {
+        var reporter = createPublicationProgressReporter({
+            title: 'Publishing version',
+            mode: 'new-version',
+            stream: stream
+        });
+        reporter.start({
+            metadata: {
+                sourceKind: 'apk-file',
+                fileName: 'app-release.apk'
+            }
+        });
+        reporter.logger.info('APK uploaded to portal storage', {
+            step: 'source.upload',
+            status: 'complete',
+            fileName: 'app-release.apk'
+        });
+        reporter.logger.info('Extracting APK metadata', {
+            step: 'ingestion.wait',
+            status: 'running',
+            ingestionStatus: 'processing',
+            ingestionStage: 'ExtractingApk',
+            ingestionDetail: 'Extracting APK metadata',
+            ingestionProgress: 45,
+            stepProgress: 0.7
+        });
+        var lines = reporter.buildLines();
+        expect(reporter.getProgressPercent()).toBeGreaterThan(0.55);
+        expect(lines[1]).toContain('57%');
+        expect(lines).toContain('Ingestion: Extracting APK metadata (45%)');
+    } finally{
+        logSpy.mockRestore();
+    }
+});
+test('ingestion detail and percentage are rendered while polling', function() {
+    var logSpy = jest.spyOn(console, 'log').mockImplementation(function() {});
+    var stream = createTestStream();
+    try {
+        var reporter = createPublicationProgressReporter({
+            title: 'Publishing version',
+            mode: 'new-version',
+            stream: stream
+        });
+        reporter.start({
+            metadata: {
+                sourceKind: 'apk-file',
+                fileName: 'app-release.apk'
+            }
+        });
+        reporter.logger.info('Extracting APK metadata', {
+            step: 'ingestion.wait',
+            status: 'running',
+            ingestionStatus: 'processing',
+            ingestionProgress: 45,
+            ingestionStage: 'ExtractingApk',
+            ingestionDetail: 'Extracting APK metadata',
+            stepProgress: 0.45
+        });
+        var lines = reporter.buildLines();
+        expect(lines).toContain('Ingestion: Extracting APK metadata (45%)');
+    } finally{
+        logSpy.mockRestore();
+    }
+});
+test('verbose mode prints detailed identifiers as they arrive', function() {
+    var logSpy = jest.spyOn(console, 'log').mockImplementation(function() {});
+    var stream = createTestStream();
+    try {
+        var reporter = createPublicationProgressReporter({
+            title: 'Publishing version',
+            mode: 'new-version',
+            verbose: true,
+            stream: stream
+        });
+        reporter.start({
+            metadata: {
+                sourceKind: 'apk-file',
+                fileName: 'app-release.apk'
+            }
+        });
+        reporter.logger.info('Ingestion session created', {
+            step: 'ingestion.create',
+            status: 'complete',
+            releaseId: 'release-123',
+            ingestionSessionId: 'ingestion-456'
+        });
+        reporter.logger.info('Publication session loaded', {
+            step: 'session.load',
+            status: 'complete',
+            publicationSessionId: 'session-789'
+        });
+        reporter.logger.info('Release NFT transaction submitted', {
+            step: 'mint.submit',
+            status: 'complete',
+            transactionSignature: 'release-tx-sig'
+        });
+        reporter.logger.info('Release collection verified', {
+            step: 'verify.submit',
+            status: 'complete',
+            transactionSignature: 'collection-tx-sig'
+        });
+        reporter.logger.info('Attestation payload created', {
+            step: 'attestation.create',
+            status: 'complete',
+            requestUniqueId: 'attest-111'
+        });
+        reporter.logger.info('Release submitted to store', {
+            step: 'submit.store',
+            status: 'complete',
+            hubspotTicketId: 'ticket-222'
+        });
+        var output = stream.output.join('');
+        expect(output).toContain('Verbose: Release ID: release-123');
+        expect(output).toContain('Verbose: Ingestion session ID: ingestion-456');
+        expect(output).toContain('Verbose: Publication session ID: session-789');
+        expect(output).toContain('Verbose: Release transaction signature: release-tx-sig');
+        expect(output).toContain('Verbose: Collection transaction signature: collection-tx-sig');
+        expect(output).toContain('Verbose: Attestation request ID: attest-111');
+        expect(output).toContain('Verbose: Ticket ID: ticket-222');
+    } finally{
+        logSpy.mockRestore();
+    }
+});

package/lib/{commands/ValidateCommand.js → publication/__tests__/fundingPreflight.test.js}

@@ -118,78 +118,102 @@ function _ts_generator(thisArg, body) {
         };
     }
 }
-import { createAppJson, createReleaseJson, validateApp, validateRelease, metaplexFileReplacer } from "@solana-mobile/dapp-store-publishing-tools";
-import { debug, showMessage } from "../CliUtils.js";
-import { loadPublishDetailsWithChecks } from "../config/PublishDetails.js";
-export var validateCommand = function(param) {
-    var signer = param.signer, buildToolsPath = param.buildToolsPath;
-    return _async_to_generator(function() {
-        var _ref, publisherDetails, appDetails, releaseDetails, appJson, _appJson_image, _e_message, errorMsg, releaseJson, objStringified, _e_message1, errorMsg1;
-        return _ts_generator(this, function(_state) {
-            switch(_state.label){
-                case 0:
-                    return [
-                        4,
-                        loadPublishDetailsWithChecks(buildToolsPath)
-                    ];
-                case 1:
-                    _ref = _state.sent(), publisherDetails = _ref.publisher, appDetails = _ref.app, releaseDetails = _ref.release;
-                    debug({
-                        publisherDetails: publisherDetails,
-                        appDetails: appDetails,
-                        releaseDetails: releaseDetails
-                    });
-                    appJson = createAppJson(appDetails, signer.publicKey);
-                    if (typeof appJson.image !== "string") {
-                        ;
-                        appJson.image = (_appJson_image = appJson.image) === null || _appJson_image === void 0 ? void 0 : _appJson_image.fileName;
-                    }
-                    debug("appJson=", JSON.stringify({
-                        appJson: appJson
-                    }, metaplexFileReplacer, 2));
-                    try {
-                        validateApp(appJson);
-                    } catch (e) {
-                        ;
-                        errorMsg = (_e_message = e === null || e === void 0 ? void 0 : e.message) !== null && _e_message !== void 0 ? _e_message : "";
-                        showMessage("App JSON invalid", errorMsg, "error");
+import { describe, expect, it, jest } from "@jest/globals";
+import { PublicKey } from "@solana/web3.js";
+import { ensurePublicationSignerBalance, MIN_PUBLICATION_SIGNER_BALANCE_LAMPORTS, resolveFundingPreflightRpcUrl } from "../fundingPreflight.js";
+describe("resolveFundingPreflightRpcUrl", function() {
+    it("defaults to mainnet when local-dev is not enabled", function() {
+        expect(resolveFundingPreflightRpcUrl({})).toBe("https://api.mainnet-beta.solana.com");
+    });
+    it("skips the default RPC in local-dev mode", function() {
+        expect(resolveFundingPreflightRpcUrl({
+            localDev: true
+        })).toBeUndefined();
+    });
+    it("honors an explicit RPC URL", function() {
+        expect(resolveFundingPreflightRpcUrl({
+            localDev: true,
+            rpcUrl: "https://rpc.example.com"
+        })).toBe("https://rpc.example.com");
+    });
+});
+describe("ensurePublicationSignerBalance", function() {
+    var publicKey = new PublicKey(new Uint8Array(32).fill(7)).toBase58();
+    it("throws before publication when the signer balance is too low", function() {
+        return _async_to_generator(function() {
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            expect(ensurePublicationSignerBalance({
+                                publicKey: publicKey
+                            }, function() {
+                                return {
+                                    getBalance: jest.fn().mockResolvedValue(MIN_PUBLICATION_SIGNER_BALANCE_LAMPORTS - 1)
+                                };
+                            })).rejects.toThrow("publishing needs at least")
+                        ];
+                    case 1:
+                        _state.sent();
                         return [
                             2
                         ];
-                    }
-                    return [
-                        4,
-                        createReleaseJson({
-                            releaseDetails: releaseDetails,
-                            appDetails: appDetails,
-                            publisherDetails: publisherDetails
-                        }, signer.publicKey)
-                    ];
-                case 2:
-                    releaseJson = _state.sent();
-                    if (appDetails.android_package != releaseDetails.android_details.android_package) {
-                        showMessage("App package name and release package name do not match", "App release specifies " + appDetails.android_package + " while release specifies " + releaseDetails.android_details.android_package, "error");
+                }
+            });
+        })();
+    });
+    it("returns without warning when the signer balance is sufficient", function() {
+        return _async_to_generator(function() {
+            var result;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            ensurePublicationSignerBalance({
+                                publicKey: publicKey
+                            }, function() {
+                                return {
+                                    getBalance: jest.fn().mockResolvedValue(MIN_PUBLICATION_SIGNER_BALANCE_LAMPORTS + 1)
+                                };
+                            })
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        expect(result).toBeUndefined();
                         return [
                             2
                         ];
-                    }
-                    objStringified = JSON.stringify(releaseJson, metaplexFileReplacer, 2);
-                    debug("releaseJson=", objStringified);
-                    try {
-                        validateRelease(JSON.parse(objStringified));
-                    } catch (e) {
-                        ;
-                        errorMsg1 = (_e_message1 = e === null || e === void 0 ? void 0 : e.message) !== null && _e_message1 !== void 0 ? _e_message1 : "";
-                        showMessage("Release JSON invalid", errorMsg1, "error");
+                }
+            });
+        })();
+    });
+    it("returns a warning when the RPC balance check fails", function() {
+        return _async_to_generator(function() {
+            var result;
+            return _ts_generator(this, function(_state) {
+                switch(_state.label){
+                    case 0:
+                        return [
+                            4,
+                            ensurePublicationSignerBalance({
+                                publicKey: publicKey
+                            }, function() {
+                                return {
+                                    getBalance: jest.fn().mockRejectedValue(new Error("RPC timeout"))
+                                };
+                            })
+                        ];
+                    case 1:
+                        result = _state.sent();
+                        expect(result).toContain("Continuing without a SOL preflight check");
+                        expect(result).toContain("RPC timeout");
                         return [
                             2
                         ];
-                    }
-                    showMessage("Json is Valid", "Input data is valid", "standard");
-                    return [
-                        2
-                    ];
-            }
-        });
-    })();
-};
+                }
+            });
+        })();
+    });
+});

package/lib/publication/__tests__/publicationSummary.test.js

@@ -0,0 +1,26 @@
+import { expect, test } from '@jest/globals';
+import { extractPublicationSummaryLines } from '../publicationSummary';
+test('summary keeps the completion message and only the compact fields', function() {
+    var lines = extractPublicationSummaryLines({
+        releaseId: 'release-123',
+        publicationSessionId: 'session-123',
+        ingestionSessionId: 'ingestion-123',
+        releaseMintAddress: 'release-mint-abc',
+        collectionMintAddress: 'collection-mint-def',
+        releaseTransactionSignature: 'release-tx',
+        collectionTransactionSignature: 'collection-tx',
+        attestationRequestUniqueId: 'attest-123',
+        hubspotTicketId: 'ticket-123'
+    });
+    expect(lines).toEqual([
+        'This app is now in review.',
+        'Release mint address: release-mint-abc',
+        'Collection mint address: collection-mint-def',
+        'Ticket ID: ticket-123'
+    ]);
+});
+test('summary still shows the in-review message when no fields are available', function() {
+    expect(extractPublicationSummaryLines(undefined)).toEqual([
+        'This app is now in review.'
+    ]);
+});