@bravemobile/react-native-code-push 8.3.1 → 9.0.0-alpha.1

package/cli/utils/file-utils.js

@@ -0,0 +1,42 @@
+/**
+ * code based on appcenter-cli
+ */
+
+const fs = require('fs');
+
+/**
+ *
+ * @param path {string}
+ * @return {boolean}
+ */
+function isDirectory(path) {
+    return fs.statSync(path).isDirectory();
+}
+
+/**
+ *
+ * @param length {number}
+ * @return {string}
+ */
+function generateRandomFilename(length) {
+    let filename = '';
+    const validChar = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+    for (let i = 0; i < length; i++) {
+        filename += validChar.charAt(Math.floor(Math.random() * validChar.length));
+    }
+
+    return filename;
+}
+
+/**
+ *
+ * @param filePath {string}
+ * @return {string}
+ */
+function normalizePath(filePath) {
+    //replace all backslashes coming from cli running on windows machines by slashes
+    return filePath.replace(/\\/g, '/');
+}
+
+module.exports = { isDirectory, generateRandomFilename, normalizePath };

package/cli/utils/fsUtils.js

@@ -0,0 +1,49 @@
+const fs = require("fs");
+const path = require("path");
+
+/**
+ * allows to require a config file with .ts extension
+ * @param filePath {string}
+ * @returns {*} FIXME type
+ */
+function requireConfig(filePath) {
+  const ext = path.extname(filePath);
+
+  if (ext === '.ts') {
+    try {
+      require('ts-node/register');
+    } catch {
+      console.error('ts-node not found. Please install ts-node as a devDependency.');
+      process.exit(1);
+    }
+  } else if (ext === '.js') {
+    // do nothing
+  } else {
+    throw new Error(`Unsupported file extension: ${ext}`);
+  }
+
+  return require(filePath);
+}
+
+/**
+ * @param startDir {string}
+ * @param configFileName {string}
+ * @returns {*|null} FIXME type
+ */
+function findAndReadConfigFile(startDir, configFileName) {
+  let dir = startDir;
+
+  while (dir !== path.parse(dir).root) {
+    const configPath = path.join(dir, configFileName);
+    if (fs.existsSync(configPath)) {
+      const config = requireConfig(configPath);
+      return config;
+    }
+    dir = path.dirname(dir);
+  }
+
+  console.error(`${configFileName} not found.`);
+  return null;
+}
+
+module.exports = { findAndReadConfigFile };

package/cli/utils/hash-utils.js

@@ -0,0 +1,227 @@
+/**
+ * code based on appcenter-cli
+ */
+
+/**
+ * NOTE!!! This utility file is duplicated for use by the CodePush service (for server-driven hashing/
+ * integrity checks) and Management SDK (for end-to-end code signing), please keep them in sync.
+ */
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { isDirectory } = require('./file-utils');
+const { walk } = require('./promisfied-fs');
+
+// Do not throw an exception if either of these modules are missing, as they may not be needed by the
+// consumer of this file.
+const HASH_ALGORITHM = 'sha256';
+class PackageManifest {
+    /**
+     * @type {Map<string, string>}
+     * @private
+     */
+    _map;
+
+    /**
+     * @param map {Map<string, string>?}
+     * @public
+     */
+    constructor(map) {
+        if (map == null) {
+            map = new Map();
+        }
+        this._map = map;
+    }
+
+    /**
+     * @return {Map<string, string>}
+     * @public
+     */
+    toMap() {
+        return this._map;
+    }
+
+    /**
+     * @return {string}
+     * @public
+     */
+    computePackageHash() {
+        /**
+         * @type {string[]}
+         */
+        let entries = [];
+        this._map.forEach((hash, name) => {
+            entries.push(name + ':' + hash);
+        });
+
+        // Make sure this list is alphabetically ordered so that other clients
+        // can also compute this hash easily given the update contents.
+        entries = entries.sort();
+
+        return crypto.createHash(HASH_ALGORITHM).update(JSON.stringify(entries)).digest('hex');
+    }
+
+    /**
+     * @return {string}
+     * @public
+     */
+    serialize() {
+        const obj = {};
+
+        this._map.forEach(function (value, key) {
+            obj[key] = value;
+        });
+
+        return JSON.stringify(obj);
+    }
+
+    /**
+     * @param filePath {string}
+     * @return {string}
+     * @public
+     */
+    static normalizePath(filePath) {
+        //replace all backslashes coming from cli running on windows machines by slashes
+        return filePath.replace(/\\/g, '/');
+    }
+
+    /**
+     * @param relativeFilePath {string}
+     * @return {boolean}
+     * @public
+     */
+    static isIgnored(relativeFilePath) {
+        const __MACOSX = '__MACOSX/';
+        const DS_STORE = '.DS_Store';
+        const CODEPUSH_METADATA = '.codepushrelease';
+        return (
+            relativeFilePath.startsWith(__MACOSX) ||
+            relativeFilePath === DS_STORE ||
+            relativeFilePath.endsWith('/' + DS_STORE) ||
+            relativeFilePath === CODEPUSH_METADATA ||
+            relativeFilePath.endsWith('/' + CODEPUSH_METADATA)
+        );
+    }
+}
+
+/**
+ *
+ * @param directoryPath {string}
+ * @param basePath {string}
+ * @return {Promise<string>}
+ */
+async function generatePackageHashFromDirectory(directoryPath, basePath) {
+    try {
+        if (!isDirectory(directoryPath)) {
+            throw new Error('Not a directory. Please either create a directory, or use hashFile().');
+        }
+    } catch (error) {
+        throw new Error('Directory does not exist. Please either create a directory, or use hashFile().');
+    }
+
+    /**
+     * @type {PackageManifest}
+     */
+    const manifest = await generatePackageManifestFromDirectory(directoryPath, basePath);
+    return manifest.computePackageHash();
+}
+
+/**
+ *
+ * @param directoryPath {string}
+ * @param basePath {string}
+ * @return {Promise<PackageManifest>}
+ */
+function generatePackageManifestFromDirectory(directoryPath, basePath) {
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve, reject) => {
+        /**
+         * @type {Map<string, string>}
+         */
+        const fileHashesMap = new Map();
+
+        /**
+         * @type {string[]}
+         */
+        const files = await walk(directoryPath);
+
+        if (!files || files.length === 0) {
+            reject('Error: Cannot sign the release because no files were found.');
+            return;
+        }
+
+        /**
+         * @type {Promise<void>}
+         */
+        // Hash the files sequentially, because streaming them in parallel is not necessarily faster
+        const generateManifestPromise = files.reduce((soFar, filePath) => {
+            return soFar.then(() => {
+                /**
+                 * @type {string}
+                 */
+                const relativePath = PackageManifest.normalizePath(path.relative(basePath, filePath));
+                if (!PackageManifest.isIgnored(relativePath)) {
+                    return hashFile(filePath).then((hash) => {
+                        fileHashesMap.set(relativePath, hash);
+                    });
+                }
+            });
+        }, Promise.resolve(null));
+
+        generateManifestPromise.then(() => {
+            resolve(new PackageManifest(fileHashesMap));
+        }, reject);
+    });
+}
+
+/**
+ *
+ * @param filePath {string}
+ * @return {Promise<string>}
+ */
+function hashFile(filePath) {
+    /**
+     * @type {fs.ReadStream}
+     */
+    const readStream = fs.createReadStream(filePath);
+    return hashStream(readStream);
+}
+
+/**
+ *
+ * @param readStream {stream.Readable}
+ * @return {Promise<string>}
+ */
+function hashStream(readStream) {
+    return new Promise((resolve, reject) => {
+        /**
+         * @type {stream.Transform}
+         */
+        const _hashStream = crypto.createHash(HASH_ALGORITHM)
+
+        readStream
+            .on('error', (error) => {
+                _hashStream.end();
+                reject(error);
+            })
+            .on('end', () => {
+                _hashStream.end();
+
+                /**
+                 * @type {Buffer}
+                 */
+                const buffer = _hashStream.read();
+                /**
+                 * @type {string}
+                 */
+                const hash = buffer.toString('hex');
+
+                resolve(hash);
+            });
+
+        readStream.pipe(_hashStream);
+    });
+}
+
+module.exports = { generatePackageHashFromDirectory };

package/cli/utils/promisfied-fs.js

@@ -0,0 +1,29 @@
+/**
+ * code based on appcenter-cli
+ */
+
+const { promises: fs } = require('fs');
+const path = require('path');
+
+/**
+ *
+ * @param dir {string}
+ * @return {Promise<string[]>}
+ */
+async function walk(dir) {
+    const stats = await fs.stat(dir);
+    if (stats.isDirectory()) {
+        /**
+         * @type {string[]}
+         */
+        let files = [];
+        for (const file of await fs.readdir(dir)) {
+            files = files.concat(await walk(path.join(dir, file)));
+        }
+        return files;
+    } else {
+        return [dir];
+    }
+}
+
+module.exports = { walk };

package/cli/utils/showLogo.js

@@ -0,0 +1,23 @@
+function showLogo() {
+  const logo = `
+    
++------------------------------------------------------------------+
+|                                                                  |
+|             ______          __     ____             __           |
+|             / ____/___  ____/ /__  / __ \\__  _______/ /_         |
+|            / /   / __ \\/ __  / _ \\/ /_/ / / / / ___/ __ \\        |
+|           / /___/ /_/ / /_/ /  __/ ____/ /_/ (__  ) / / /        |
+|           \\____/\\____/\\__,_/\\___/_/    \\__,_/____/_/ /_/         |
+|                                                                  |
+|                                                                  |
+|              🚀 @bravemobile/react-native-code-push              |
++------------------------------------------------------------------+                                     
+
+Please refer to help command for more information.
+
+(interactive mode is not supported yet.)
+    `;
+  console.log(logo);
+}
+
+module.exports = { showLogo };

package/cli/utils/zip.js

@@ -0,0 +1,89 @@
+/**
+ * code based on appcenter-cli
+ */
+
+const fs = require('fs');
+const path = require('path');
+const yazl = require('yazl');
+const { generateRandomFilename, normalizePath, isDirectory } = require('./file-utils');
+const { walk } = require('./promisfied-fs');
+
+/**
+ * @typedef {{ sourceLocation: string, targetLocation: string }} ReleaseFile
+ */
+
+/**
+ * @param updateContentsPath {string}
+ * @return {Promise<string>}
+ */
+function zip(updateContentsPath) {
+
+    // eslint-disable-next-line no-async-promise-executor
+    return new Promise(async (resolve, reject) => {
+        /**
+         * @type {ReleaseFile[]}
+         */
+        const releaseFiles = [];
+
+        try {
+            if (!isDirectory(updateContentsPath)) {
+                releaseFiles.push({
+                    sourceLocation: updateContentsPath,
+                    targetLocation: normalizePath(path.basename(updateContentsPath)), // Put the file in the root
+                });
+            }
+        } catch (error) {
+            error.message = error.message + ' Make sure you have added the platform you are making a release to.`.';
+            reject(error);
+        }
+
+        /**
+         * @type {string}
+         */
+        const directoryPath = updateContentsPath;
+        const baseDirectoryPath = path.join(directoryPath, '..'); // For legacy reasons, put the root directory in the zip
+
+        /**
+         * @type {string[]}
+         */
+        const files = await walk(updateContentsPath);
+
+        files.forEach((filePath) => {
+            /**
+             * @type {string}
+             */
+            const relativePath = path.relative(baseDirectoryPath, filePath);
+            releaseFiles.push({
+                sourceLocation: filePath,
+                targetLocation: normalizePath(relativePath),
+            });
+        });
+
+        /**
+         * @type {string}
+         */
+        const packagePath = path.join(process.cwd(), generateRandomFilename(15) + '.zip');
+        const zipFile = new yazl.ZipFile();
+        /**
+         * @type {fs.WriteStream}
+         */
+        const writeStream = fs.createWriteStream(packagePath);
+
+        zipFile.outputStream
+            .pipe(writeStream)
+            .on('error', (error) => {
+                reject(error);
+            })
+            .on('close', () => {
+                resolve(packagePath);
+            });
+
+        releaseFiles.forEach((releaseFile) => {
+            zipFile.addFile(releaseFile.sourceLocation, releaseFile.targetLocation);
+        });
+
+        zipFile.end();
+    });
+}
+
+module.exports = zip;

package/code-push.config.example.supabase.ts

@@ -0,0 +1,114 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
+
+import {
+    CliConfigInterface,
+    ReleaseHistoryInterface,
+} from "@bravemobile/react-native-code-push";
+import * as fs from "fs";
+import axios from "axios"; // install as devDependency
+import * as SupabaseSDK from "@supabase/supabase-js"; // install as devDependency
+
+const SUPABASE_URL = process.env.SUPABASE_URL;
+const SUPABASE_KEY = process.env.SUPABASE_KEY;
+const supabase = SupabaseSDK.createClient(SUPABASE_URL!, SUPABASE_KEY!);
+const BUCKET_NAME = "codePush";
+const STORAGE_HOST = `${SUPABASE_URL}/storage/v1/object/public`;
+
+function historyJsonFileRemotePath(
+    platform: "ios" | "android",
+    identifier: string,
+    binaryVersion: string,
+) {
+    return `histories/${platform}/${identifier}/${binaryVersion}.json`;
+}
+
+function bundleFileRemotePath(
+    platform: "ios" | "android",
+    identifier: string,
+    fileName: string,
+) {
+    return `bundles/${platform}/${identifier}/${fileName}`;
+}
+
+const Config: CliConfigInterface = {
+    bundleUploader: async (
+        source: string,
+        platform: "ios" | "android",
+        identifier = "staging",
+    ): Promise<{downloadUrl: string}> => {
+        const fileName = source.split("/").pop();
+        const fileStream = fs.createReadStream(source);
+        const remotePath = bundleFileRemotePath(platform, identifier, fileName!);
+
+        const {data, error} = await supabase.storage
+            .from(BUCKET_NAME)
+            .upload(remotePath, fileStream, {
+                contentType: "application/zip",
+                duplex: "half",
+            });
+
+        if (error) {
+            console.error("Error uploading file:", error.message);
+            throw error;
+        }
+
+        console.log("Bundle File uploaded:", `${STORAGE_HOST}/${data.fullPath}`);
+
+        return {
+            downloadUrl: `${STORAGE_HOST}/${data.fullPath}`,
+        };
+    },
+
+    getReleaseHistory: async (
+        targetBinaryVersion: string,
+        platform: "ios" | "android",
+        identifier = "staging",
+    ): Promise<ReleaseHistoryInterface> => {
+        const remoteJsonPath = historyJsonFileRemotePath(
+            platform,
+            identifier,
+            targetBinaryVersion,
+        );
+        const {data} = await axios.get(
+            `${STORAGE_HOST}/${BUCKET_NAME}/${remoteJsonPath}`,
+        );
+        return data as ReleaseHistoryInterface;
+    },
+
+    setReleaseHistory: async (
+        targetBinaryVersion: string,
+        jsonFilePath: string,
+        releaseInfo: ReleaseHistoryInterface,
+        platform: "ios" | "android",
+        identifier = "staging",
+    ): Promise<void> => {
+        // upload JSON file or call API using `releaseInfo` metadata.
+
+        const fileContent = fs.readFileSync(jsonFilePath, "utf8");
+        const remoteJsonPath = historyJsonFileRemotePath(
+            platform,
+            identifier,
+            targetBinaryVersion,
+        );
+
+        const {data, error} = await supabase.storage
+            .from(BUCKET_NAME)
+            .upload(remoteJsonPath, Buffer.from(fileContent), {
+                contentType: "application/json",
+                cacheControl: "5",
+            });
+
+        if (error) {
+            console.error("Error uploading file:", error.message);
+            throw error;
+        }
+
+        console.log(
+            "Release history File uploaded:",
+            `${STORAGE_HOST}/${data.fullPath}`,
+        );
+    },
+};
+
+module.exports = Config;

package/docs/setup-android.md

@@ -19,15 +19,7 @@ In order to integrate CodePush into your Android project, please perform the fol
 
 ### Plugin Installation and Configuration for React Native 0.60 version and above (Android)
 
-1. In your `android/settings.gradle` file, make the following additions at the end of the file:
-
-    ```gradle
-    ...
-    include ':app', ':react-native-code-push'
-    project(':react-native-code-push').projectDir = new File(rootProject.projectDir, '../node_modules/react-native-code-push/android/app')
-    ```
-    
-2. In your `android/app/build.gradle` file, add the `codepush.gradle` file as an additional build task definition to the end of the file:
+1. In your `android/app/build.gradle` file, add the `codepush.gradle` file as an additional build task definition to the end of the file:
 
     ```gradle
     ...
@@ -35,7 +27,7 @@ In order to integrate CodePush into your Android project, please perform the fol
     ...
     ```
 
-3. Update the `MainApplication` file to use CodePush via the following changes:
+2. Update the `MainApplication` file to use CodePush via the following changes:
 
     For React Native 0.73 and above: update the `MainApplication.kt`
 
@@ -83,7 +75,7 @@ In order to integrate CodePush into your Android project, please perform the fol
     }
     ```
 
-4. Add the Deployment key to `strings.xml`:
+3. Add the Deployment key to `strings.xml`:
 
    To let the CodePush runtime know which deployment it should query for updates, open your app's `strings.xml` file and add a new string named `CodePushDeploymentKey`, whose value is the key of the deployment you want to configure this app against (like the key for the `Staging` deployment for the `FooBar` app). You can retrieve this value by running `appcenter codepush deployment list -a <ownerName>/<appName> -k` in the CodePush CLI (the `-k` flag is necessary since keys aren't displayed by default) and copying the value of the `Key` column which corresponds to the deployment you want to use (see below). Note that using the deployment's name (like Staging) will not work. The "friendly name" is intended only for authenticated management usage from the CLI, and not for public consumption within your app.
 

package/eslint.config.mjs

@@ -0,0 +1,32 @@
+import globals from "globals";
+import pluginJs from "@eslint/js";
+import tseslint from "typescript-eslint";
+import pluginReact from "eslint-plugin-react";
+
+
+export default [
+  {files: ["**/*.{js,mjs,cjs,ts,jsx,tsx}"]},
+  {languageOptions: { globals: {
+    ...globals.node,
+    ...globals.mocha,
+    ...globals.browser,
+    ...globals.jest
+  } }},
+  pluginJs.configs.recommended,
+  ...tseslint.configs.recommended,
+  pluginReact.configs.flat.recommended,
+  {"rules": {
+    "@typescript-eslint/no-require-imports": "warn",
+    "@typescript-eslint/no-unused-vars": "warn",
+    "@typescript-eslint/no-unused-expressions": "warn",
+    "no-empty": "warn",
+    "@typescript-eslint/no-explicit-any": "warn",
+    "no-var": "warn",
+    "@typescript-eslint/no-this-alias": "warn",
+    "@typescript-eslint/no-empty-object-type": "warn",
+    "react/no-deprecated": "warn",
+    "no-extra-boolean-cast": "warn",
+    "no-useless-escape": "warn",
+    "no-control-regex": "warn",
+  }}
+];

package/package-mixins.js

@@ -5,7 +5,7 @@ import log from "./logging";
 // package objects with additional functionality/properties
 // beyond what is included in the metadata sent by the server.
 module.exports = (NativeCodePush) => {
-  const remote = (reportStatusDownload) => {
+  const remote = () => {
     return {
       async download(downloadProgressCallback) {
         if (!this.downloadUrl) {
@@ -30,13 +30,6 @@ module.exports = (NativeCodePush) => {
 
           const downloadedPackage = await NativeCodePush.downloadUpdate(updatePackageCopy, !!downloadProgressCallback);
 
-          if (reportStatusDownload) {
-            reportStatusDownload(this)
-            .catch((err) => {
-              log(`Report download status failed: ${err}`);
-            });
-          }
-
           return { ...downloadedPackage, ...local };
         } finally {
           downloadProgressSubscription && downloadProgressSubscription.remove();