@solana-mobile/dapp-store-cli 0.4.2 → 0.4.3

package/src/__tests__/CliSetupTest.ts

@@ -0,0 +1,212 @@
+import { beforeEach, expect } from "@jest/globals";
+import {
+  createAppCliCmd,
+  createCliCmd,
+  createPublisherCliCmd,
+  createReleaseCliCmd,
+  initCliCmd,
+  mainCli
+} from "../CliSetup";
+import { Constants } from "../CliUtils";
+
+describe("Cli Setup & Execution", () => {
+  const outputHelpReference = "(outputHelp)"
+
+  let errorOutput: string = ""
+  let otherOutput: string = ""
+
+  beforeEach(() => {
+    errorOutput = "";
+    otherOutput = "";
+    mainCli.exitOverride();
+
+    mainCli.configureOutput({
+      getOutHelpWidth(): number { return 250; },
+      getErrHelpWidth(): number { return 250;},
+
+      writeOut(str: string) {
+        otherOutput = str;
+      },
+
+      writeErr(str: string) {
+        errorOutput = str;
+      }
+    });
+  });
+
+  test("Cli version argument reports correct version", () => {
+
+    expect(() => {
+      mainCli.parse(["npx", "dapp-store", "-V"]);
+    }).toThrow(Constants.CLI_VERSION)
+  });
+
+  test("Calling cli with no parameters displays general help", () => {
+    expect(() => {
+        mainCli.parse(["npx", "dapp-store"]);
+      }
+    ).toThrow(outputHelpReference);
+
+    expect(generalHelp).toEqual(errorOutput)
+  });
+
+  test("Calling init command with help parameter shows contextual help info", () => {
+    initCliCmd.exitOverride()
+
+    expect(() => {
+      initCliCmd.parse(["dapp-store", "init", "-h"])
+    }).toThrow(outputHelpReference)
+
+    expect(otherOutput).toEqual(initHelp)
+  })
+
+  test("Calling create command with no options lists all options", () => {
+    createCliCmd.exitOverride()
+
+    expect(() => {
+        createCliCmd.parse(["dapp-store", "create"]);
+      }
+    ).toThrow(outputHelpReference);
+
+    expect(errorOutput).toEqual(createHelp)
+  });
+
+  test("Calling create publisher command with no arguments warns about required argument", () => {
+    createPublisherCliCmd.exitOverride()
+
+    expect(() => {
+        createPublisherCliCmd.parse(["dapp-store", "create", "publisher"]);
+      }
+    ).toThrow(keyPairArgHelp);
+  });
+
+  test("Calling create publisher command with help flag shows contextual help", () => {
+    createPublisherCliCmd.exitOverride()
+
+    expect(() => {
+      createPublisherCliCmd.parse(["dapp-store", "create", "publisher", "-h"]);
+    }).toThrow(outputHelpReference)
+
+    expect(otherOutput).toEqual(createPublisherHelp)
+  });
+
+  test("Calling create app command with no arguments warns about required argument", () => {
+    createAppCliCmd.exitOverride()
+
+    expect(() => {
+      createAppCliCmd.parse(["dapp-store", "create", "app"]);
+      }
+    ).toThrow(keyPairArgHelp);
+  });
+
+  test("Calling create app command with help flag shows contextual help", () => {
+    createAppCliCmd.exitOverride()
+
+    expect(() => {
+      createAppCliCmd.parse(["dapp-store", "create", "app", "-h"]);
+    }).toThrow(outputHelpReference)
+
+    expect(otherOutput).toEqual(createAppHelp)
+  });
+
+  test("Calling create release command with no arguments warns about required argument", () => {
+    createReleaseCliCmd.exitOverride()
+
+    expect(() => {
+        createReleaseCliCmd.parse(["dapp-store", "create", "release"]);
+      }
+    ).toThrow(keyPairArgHelp);
+  });
+
+  test("Calling create release command with help flag shows contextual help", () => {
+    createReleaseCliCmd.exitOverride()
+
+    expect(() => {
+      createReleaseCliCmd.parse(["dapp-store", "create", "release", "-h"]);
+    }).toThrow(outputHelpReference)
+
+    expect(otherOutput).toEqual(createReleaseHelp)
+  });
+
+  //--------------------------------------------------
+
+  const generalHelp = `Usage: dapp-store [options] [command]
+
+CLI to assist with publishing to the Saga Dapp Store
+
+Options:
+  -V, --version       output the version number
+  -h, --help          display help for command
+
+Commands:
+  init                First-time initialization of tooling configuration
+  create              Create a \`publisher\`, \`app\`, or \`release\`
+  validate [options]  Validates details prior to publishing
+  publish             Submit a publishing request (\`submit\`, \`update\`, \`remove\`, or \`support\`) to the Solana Mobile dApp publisher portal
+  help [command]      display help for command
+`;
+
+  const initHelp = `Usage: dapp-store init [options]
+
+First-time initialization of tooling configuration
+
+Options:
+  -h, --help  display help for command
+`;
+
+  const keyPairArgHelp = "error: required option '-k, --keypair <path-to-keypair-file>' not specified"
+
+  const createHelp = `Usage: dapp-store create [options] [command]
+
+Create a \`publisher\`, \`app\`, or \`release\`
+
+Options:
+  -h, --help           display help for command
+
+Commands:
+  publisher [options]  Create a publisher
+  app [options]        Create a app
+  release [options]    Create a release
+  help [command]       display help for command
+`;
+
+  const createPublisherHelp = `Usage: dapp-store create publisher [options]
+
+Create a publisher
+
+Options:
+  -k, --keypair <path-to-keypair-file>   Path to keypair file
+  -u, --url <url>                        RPC URL (default: "https://api.devnet.solana.com")
+  -d, --dry-run                          Flag for dry run. Doesn't mint an NFT
+  -s, --storage-config <storage-config>  Provide alternative storage configuration details
+  -h, --help                             display help for command
+`;
+
+  const createAppHelp = `Usage: dapp-store create app [options]
+
+Create a app
+
+Options:
+  -k, --keypair <path-to-keypair-file>                   Path to keypair file
+  -p, --publisher-mint-address <publisher-mint-address>  The mint address of the publisher NFT
+  -u, --url <url>                                        RPC URL (default: "https://api.devnet.solana.com")
+  -d, --dry-run                                          Flag for dry run. Doesn't mint an NFT
+  -s, --storage-config <storage-config>                  Provide alternative storage configuration details
+  -h, --help                                             display help for command
+`;
+
+  const createReleaseHelp = `Usage: dapp-store create release [options]
+
+Create a release
+
+Options:
+  -k, --keypair <path-to-keypair-file>       Path to keypair file
+  -a, --app-mint-address <app-mint-address>  The mint address of the app NFT
+  -u, --url <url>                            RPC URL (default: "https://api.devnet.solana.com")
+  -d, --dry-run                              Flag for dry run. Doesn't mint an NFT
+  -b, --build-tools-path <build-tools-path>  Path to Android build tools which contains AAPT2
+  -s, --storage-config <storage-config>      Provide alternative storage configuration details
+  -h, --help                                 display help for command
+`;
+
+});

package/src/commands/create/CreateCliApp.ts

@@ -18,16 +18,18 @@ const createAppNft = async (
     connection,
     publisherMintAddress,
     publisher,
+    storageParams,
   }: {
     appDetails: App;
     connection: Connection;
     publisherMintAddress: string;
     publisher: Keypair;
+    storageParams: string;
   },
   { dryRun }: { dryRun?: boolean }
 ) => {
   const mintAddress = Keypair.generate();
-  const metaplex = getMetaplexInstance(connection, publisher);
+  const metaplex = getMetaplexInstance(connection, publisher, storageParams);
   const txBuilder = await createApp(
     {
       publisherMintAddress: new PublicKey(publisherMintAddress),
@@ -59,6 +61,7 @@ type CreateAppCommandInput = {
   signer: Keypair;
   url: string;
   dryRun?: boolean;
+  storageParams: string;
 };
 
 export const createAppCommand = async ({
@@ -66,6 +69,7 @@ export const createAppCommand = async ({
   url,
   dryRun,
   publisherMintAddress,
+  storageParams,
 }: CreateAppCommandInput) => {
   const connection = new Connection(url);
 
@@ -78,6 +82,7 @@ export const createAppCommand = async ({
       publisher: signer,
       publisherMintAddress: publisherDetails.address ?? publisherMintAddress,
       appDetails,
+      storageParams,
     },
     { dryRun }
   );

package/src/commands/create/CreateCliPublisher.ts

@@ -16,15 +16,17 @@ const createPublisherNft = async (
     connection,
     publisher,
     publisherDetails,
+    storageParams,
   }: {
     connection: Connection;
     publisher: Keypair;
     publisherDetails: Publisher;
+    storageParams: string;
   },
   { dryRun }: { dryRun: boolean }
 ) => {
   const mintAddress = Keypair.generate();
-  const metaplex = getMetaplexInstance(connection, publisher);
+  const metaplex = getMetaplexInstance(connection, publisher, storageParams);
   console.info(
     `Creating publisher at address: ${mintAddress.publicKey.toBase58()}`
   );
@@ -54,10 +56,12 @@ export const createPublisherCommand = async ({
   signer,
   url,
   dryRun,
+  storageParams,
 }: {
   signer: Keypair;
   url: string;
   dryRun: boolean;
+  storageParams: string;
 }) => {
   const connection = new Connection(url);
 
@@ -68,6 +72,7 @@ export const createPublisherCommand = async ({
       connection,
       publisher: signer,
       publisherDetails,
+      storageParams: storageParams,
     },
     { dryRun }
   );

package/src/commands/create/CreateCliRelease.ts

@@ -21,6 +21,7 @@ type CreateReleaseCommandInput = {
   signer: Keypair;
   url: string;
   dryRun?: boolean;
+  storageParams: string;
 };
 
 const createReleaseNft = async ({
@@ -30,6 +31,7 @@ const createReleaseNft = async ({
   publisherDetails,
   connection,
   publisher,
+  storageParams,
 }: {
   appMintAddress: string;
   releaseDetails: Release;
@@ -37,10 +39,11 @@ const createReleaseNft = async ({
   publisherDetails: Publisher;
   connection: Connection;
   publisher: Keypair;
+  storageParams: string;
 }) => {
   const releaseMintAddress = Keypair.generate();
 
-  const metaplex = getMetaplexInstance(connection, publisher);
+  const metaplex = getMetaplexInstance(connection, publisher, storageParams);
 
   const { txBuilder } = await createRelease(
     {
@@ -77,6 +80,7 @@ export const createReleaseCommand = async ({
   signer,
   url,
   dryRun = false,
+  storageParams,
 }: CreateReleaseCommandInput) => {
   const connection = new Connection(url);
 
@@ -92,6 +96,7 @@ export const createReleaseCommand = async ({
       },
       appDetails: app,
       publisherDetails: publisher,
+      storageParams: storageParams,
     });
 
     writeToPublishDetails({

package/src/config/EnvVariables.ts

@@ -0,0 +1,39 @@
+import * as dotenv from "dotenv";
+
+export type S3Config = {
+  accessKey: string;
+  secretKey: string;
+  bucketName: string;
+  regionName: string;
+}
+export class EnvVariables {
+
+  public get hasAndroidTools(): boolean {
+    return process.env.ANDROID_TOOLS_DIR !== undefined;
+  }
+
+  public get androidToolsDir(): string {
+    return process.env.ANDROID_TOOLS_DIR as string;
+  }
+
+  public get hasS3EnvArgs(): boolean {
+    return process.env.STORAGE_TYPE == "s3" &&
+      process.env.S3_ACCESS_KEY != undefined &&
+      process.env.S3_SECRET_KEY != undefined &&
+      process.env.S3_BUCKET != undefined &&
+      process.env.S3_REGION != undefined;
+  }
+
+  public get s3Config(): S3Config {
+    return {
+      accessKey: process.env.S3_ACCESS_KEY as string,
+      secretKey: process.env.S3_SECRET_KEY as string,
+      bucketName: process.env.S3_BUCKET as string,
+      regionName: process.env.S3_REGION as string
+    };
+  }
+
+  constructor() {
+    dotenv.config();
+  }
+}

package/src/config/PublishDetails.ts

@@ -178,10 +178,10 @@ const validateLocalizableResources = (config: PublishDetails) => {
 
   const descsWrongLength = Object.values(config.release.catalog)
     .map((x) => x.short_description)
-    .filter((desc) => !desc?.length || desc.length > 50);
+    .filter((desc) => !desc?.length || desc.length > 30);
 
   if (descsWrongLength.length > 0) {
-    throw new Error("Please ensure all translations of short_description are between 0 and 50 characters");
+    throw new Error("Please ensure all translations of short_description are between 0 and 30 characters");
   }
 };
 

package/src/config/S3StorageManager.ts

@@ -0,0 +1,47 @@
+import { EnvVariables, S3Config } from "./EnvVariables.js";
+
+export class S3StorageManager {
+  private _config: S3Config | undefined = undefined
+
+  public get hasS3Config(): boolean {
+    return this._config != undefined;
+  }
+
+  public get s3Config(): S3Config {
+    return this._config as S3Config;
+  }
+
+  constructor(private envVars: EnvVariables) {
+    if (envVars.hasS3EnvArgs) {
+      this._config = {
+        accessKey: this.envVars.s3Config.accessKey,
+        secretKey: this.envVars.s3Config.secretKey,
+        bucketName: this.envVars.s3Config.bucketName,
+        regionName: this.envVars.s3Config.regionName
+      };
+    }
+  }
+
+  parseCmdArg(cmdArg: string) {
+    if (!cmdArg || cmdArg == "") return;
+
+    try {
+      //This will overwrite any existing parameters already obtained from the .env file
+      const parsedArray = JSON.parse(`${cmdArg}`);
+
+      if (parsedArray instanceof Array && parsedArray[0] == "s3") {
+        if (parsedArray.length != 5) throw new Error("Invalid parameters")
+
+        this._config = {
+          accessKey: parsedArray[1],
+          secretKey: parsedArray[2],
+          bucketName: parsedArray[3],
+          regionName: parsedArray[4]
+        };
+      }
+    } catch (e) {
+      throw new Error("There was an error parsing your s3 parameters from the CLI. Please ensure they are formatted correctly.");
+    }
+  }
+
+}

package/src/config/index.ts

@@ -0,0 +1,2 @@
+export * from "./EnvVariables.js";
+export * from "./S3StorageManager.js";