@nordicsemiconductor/pc-nrfconnect-shared 197.0.0 → 199.0.0

package/scripts/nordic-publish.ts

@@ -6,10 +6,12 @@
  * SPDX-License-Identifier: LicenseRef-Nordic-4-Clause
  */
 
+/* eslint-disable max-classes-per-file, class-methods-use-this */
+
 import { execSync } from 'child_process';
-import { program } from 'commander';
+import { Option, program } from 'commander';
 import fs from 'fs';
-import FtpClient from 'ftp';
+import LowlevelFtpClient from 'ftp';
 import semver from 'semver';
 import calculateShasum from 'shasum';
 
@@ -30,7 +32,201 @@ interface App {
     packageJson: PackageJsonApp;
 }
 
-const client = new FtpClient();
+let client: Client;
+
+abstract class Client {
+    abstract sourceUrl: string;
+
+    initialise(options: Options): Promise<void> | void {} // eslint-disable-line @typescript-eslint/no-unused-vars
+    end(): void {}
+
+    abstract download(filename: string): Promise<string>;
+    abstract uploadContent(
+        content: Buffer,
+        remoteFilename: string
+    ): Promise<void>;
+    abstract uploadLocalFile(
+        localFilename: string,
+        remoteFilename: string
+    ): Promise<void>;
+}
+
+class FtpClient extends Client {
+    /*
+     * To use this script with an FTP server REPO_HOST, REPO_USER and REPO_PASS need to be set
+     */
+
+    ftpClient = new LowlevelFtpClient();
+
+    host = process.env.REPO_HOST || 'localhost';
+    port = Number(process.env.REPO_PORT) || 21;
+    user = process.env.REPO_USER || 'anonymous';
+    password = process.env.REPO_PASS || 'anonymous@';
+
+    sourceDir: string;
+    sourceUrl: string;
+
+    constructor(private readonly options: Options) {
+        super();
+        this.sourceDir = this.getSourceDir();
+        this.sourceUrl = this.getSourceUrl();
+    }
+
+    getSourceDir = () => {
+        const repoDirOfficial = '/.pc-tools/nrfconnect-apps';
+
+        if (process.env.REPO_DIR) return process.env.REPO_DIR;
+        if (this.options.deployOfficial) return repoDirOfficial;
+
+        return `${repoDirOfficial}/${this.options.source}`;
+    };
+
+    getSourceUrl = () => {
+        if (process.env.REPO_URL) return process.env.REPO_URL;
+        return `https://developer.nordicsemi.com${this.sourceDir}`;
+    };
+
+    connect = () =>
+        new Promise<void>((resolve, reject) => {
+            console.log(
+                `Connecting to ftp://${this.user}@${this.host}:${this.port}`
+            );
+            this.ftpClient.once('error', err => {
+                this.ftpClient.removeAllListeners('ready');
+                reject(err);
+            });
+            this.ftpClient.once('ready', () => {
+                this.ftpClient.removeAllListeners('error');
+                resolve();
+            });
+            this.ftpClient.connect({
+                host: this.host,
+                port: this.port,
+                user: this.user,
+                password: this.password,
+            });
+        });
+
+    changeWorkingDirectory = () =>
+        new Promise<void>((resolve, reject) => {
+            console.log(`Changing to directory ${this.sourceDir}`);
+            this.ftpClient.cwd(this.sourceDir, err => {
+                if (err) {
+                    reject(
+                        new Error(
+                            '\nError: Failed to change to directory. ' +
+                                'Check whether it exists on the FTP server.'
+                        )
+                    );
+                } else {
+                    resolve();
+                }
+            });
+        });
+
+    initialise = async () => {
+        await this.connect();
+        await this.changeWorkingDirectory();
+    };
+
+    download = (filename: string) =>
+        new Promise<string>((resolve, reject) => {
+            console.log(`Downloading file ${filename}`);
+            let data = '';
+            this.ftpClient.get(filename, (err, stream) => {
+                if (err) return reject(err);
+                stream.once('close', () => resolve(data));
+                stream.on('data', chunk => {
+                    data += chunk;
+                });
+                return undefined;
+            });
+        });
+
+    upload = (
+        contentOrLocalFilename: string | Buffer,
+        remoteFilename: string
+    ) =>
+        new Promise<void>((resolve, reject) => {
+            console.log(`Uploading file ${remoteFilename}`);
+            this.ftpClient.put(contentOrLocalFilename, remoteFilename, err =>
+                err ? reject(err) : resolve()
+            );
+        });
+
+    uploadContent = this.upload;
+    uploadLocalFile = this.upload;
+
+    end = () => this.ftpClient.end();
+}
+
+class ArtifactoryClient extends Client {
+    token = process.env.ARTIFACTORY_TOKEN;
+
+    sourceUrl: string;
+
+    constructor(private readonly options: Options) {
+        super();
+
+        if (this.token == null) {
+            throw new Error(
+                'The environment variable ARTIFACTORY_TOKEN must be set.'
+            );
+        }
+
+        this.sourceUrl = `https://files.nordicsemi.com/artifactory/swtools/${this.getAccessLevel()}/ncd/apps/${
+            options.source
+        }`;
+    }
+
+    getAccessLevel = () => {
+        if (this.options.accessLevel != null) return this.options.accessLevel;
+
+        return this.options.deployOfficial ? 'external' : 'internal';
+    };
+
+    download = async (filename: string) => {
+        console.log(`Downloading ${filename}`);
+
+        const url = `${this.sourceUrl}/${filename}`;
+        const res = await fetch(url, {
+            headers: { Authorization: `Bearer ${this.token}` },
+        });
+
+        if (!res.ok) {
+            throw new Error(`Failed to download ${url}: ${res.statusText}`);
+        }
+
+        return res.text();
+    };
+
+    upload = async (content: Buffer, remoteFilename: string) => {
+        const url = `${this.sourceUrl}/${remoteFilename}`;
+        const res = await fetch(url, {
+            method: 'PUT',
+            body: content,
+            headers: { Authorization: `Bearer ${this.token}` },
+        });
+
+        if (!res.ok) {
+            throw new Error(`Failed to upload ${url}: ${res.statusText}`);
+        }
+    };
+
+    uploadContent = (content: Buffer, remoteFilename: string) => {
+        console.log(`Uploading content for ${remoteFilename}`);
+
+        return this.upload(content, remoteFilename);
+    };
+
+    uploadLocalFile = (localFilename: string, remoteFilename: string) => {
+        console.log(
+            `Uploading local file ${localFilename} as ${remoteFilename}`
+        );
+
+        return this.upload(fs.readFileSync(localFilename), remoteFilename);
+    };
+}
 
 const hasMessage = (error: unknown): error is { message: unknown } =>
     error != null && typeof error === 'object' && 'message' in error;
@@ -38,64 +234,84 @@ const hasMessage = (error: unknown): error is { message: unknown } =>
 const errorAsString = (error: unknown) =>
     hasMessage(error) ? error.message : String(error);
 
-const getSourceDir = (deployOfficial: boolean, sourceName: string) => {
-    const repoDirOfficial = '/.pc-tools/nrfconnect-apps';
+const validAccessLevels = [
+    'external',
+    'external-confidential',
+    'internal',
+    'internal-confidential',
+] as const;
 
-    if (process.env.REPO_DIR) return process.env.REPO_DIR;
-    if (deployOfficial) return repoDirOfficial;
+type AccessLevel = (typeof validAccessLevels)[number];
 
-    return `${repoDirOfficial}/${sourceName}`;
-};
+const isAccessLevel = (value: string): value is AccessLevel =>
+    (validAccessLevels as readonly string[]).includes(value);
+
+const splitSourceAndAccessLevel = (sourceAndMaybeAccessLevel: string) => {
+    const match = sourceAndMaybeAccessLevel.match(
+        /(?<source>.*?)\s*\((?<accessLevel>.*)\)/
+    );
 
-const getSourceUrl = (deployOfficial: boolean, sourceName: string) => {
-    const repoUrlOfficial =
-        'https://developer.nordicsemi.com/.pc-tools/nrfconnect-apps';
+    if (match == null) {
+        return { source: sourceAndMaybeAccessLevel };
+    }
 
-    if (process.env.REPO_URL) return process.env.REPO_URL;
-    if (deployOfficial) return repoUrlOfficial;
+    const { source, accessLevel } = match.groups!; // eslint-disable-line @typescript-eslint/no-non-null-assertion -- Can never be null because of the regex
 
-    return `${repoUrlOfficial}/${sourceName}`;
+    if (!isAccessLevel(accessLevel)) {
+        throw new Error(
+            `The specified access level "${accessLevel}" must be one of ${validAccessLevels.join(
+                ', '
+            )}.`
+        );
+    }
+
+    return { source, accessLevel };
 };
 
 interface Options {
     doPack: boolean;
-    doCreateSource: boolean;
     deployOfficial: boolean;
-    sourceDir: string;
-    sourceUrl: string;
+    source: string;
     sourceName?: string;
+    destination: 'ftp' | 'artifactory';
+    accessLevel?: AccessLevel;
 }
 
 const parseOptions = (): Options => {
     program
-        .description('Publish to nordic repository')
+        .description('Publish an nRF Connect for Desktop app')
         .requiredOption(
             '-s, --source <source>',
-            'Specify the source to publish (e.g. official).'
+            'Specify the source to publish (e.g. "official" or "releast-test"). ' +
+                'When publishing to Artifactory, an access level can be ' +
+                'specified at the end in parantheses (e.g. "official (external)").'
+        )
+        .addOption(
+            new Option(
+                '-d, --destination <ftp|artifactory>',
+                'Specify where to publish.'
+            )
+                .choices(['ftp', 'artifactory'])
+                .makeOptionMandatory()
         )
         .option(
             '-n, --no-pack',
             'Publish existing .tgz file at the root directory without npm pack.'
         )
-        .option(
-            '--create-source <source name>',
-            'Do not fail if the source specifiec with --source does not yet ' +
-                'exist but instead create a new source with this name ' +
-                '(e.g. "Release Test").'
-        )
         .parse();
 
     const options = program.opts();
 
-    const deployOfficial = options.source === 'official';
+    const { source, accessLevel } = splitSourceAndAccessLevel(options.source);
+
+    const deployOfficial = source === 'official';
 
     return {
         doPack: options.pack,
-        doCreateSource: options.createSource != null,
-        sourceName: options.createSource,
+        source,
         deployOfficial,
-        sourceDir: getSourceDir(deployOfficial, options.source),
-        sourceUrl: getSourceUrl(deployOfficial, options.source),
+        destination: options.destination,
+        accessLevel,
     };
 };
 
@@ -144,7 +360,7 @@ const packOrReadPackage = (options: Options): App => {
         version,
         filename,
         shasum,
-        sourceUrl: options.sourceUrl,
+        sourceUrl: client.sourceUrl,
         isOfficial: options.deployOfficial,
         appInfoName: `${name}.json`,
         releaseNotesFilename: `${name}-Changelog.md`,
@@ -153,72 +369,6 @@ const packOrReadPackage = (options: Options): App => {
     };
 };
 
-const connect = (config: {
-    host: string;
-    port: number;
-    user: string;
-    password: string;
-}) =>
-    new Promise<void>((resolve, reject) => {
-        console.log(
-            `Connecting to ftp://${config.user}@${config.host}:${config.port}`
-        );
-        client.once('error', err => {
-            client.removeAllListeners('ready');
-            reject(err);
-        });
-        client.once('ready', () => {
-            client.removeAllListeners('error');
-            resolve();
-        });
-        client.connect(config);
-    });
-
-const createSourceDirectory = (dir: string) =>
-    new Promise<void>((resolve, reject) => {
-        console.log(`Creating source directory ${dir}`);
-        client.mkdir(dir, true, err => {
-            if (err) {
-                reject(new Error(`Failed to create source directory.`));
-            } else {
-                resolve();
-            }
-        });
-    });
-
-const changeWorkingDirectory = (dir: string) =>
-    new Promise<void>((resolve, reject) => {
-        console.log(`Changing to directory ${dir}`);
-        client.cwd(dir, err => {
-            if (err) {
-                reject(
-                    new Error(
-                        '\nError: Failed to change to directory. ' +
-                            'Check whether it exists on the FTP server.\n' +
-                            'If you want to create a new source, use the ' +
-                            '--create-source option.'
-                    )
-                );
-            } else {
-                resolve();
-            }
-        });
-    });
-
-const downloadFileContent = (filename: string) =>
-    new Promise<string>((resolve, reject) => {
-        console.log(`Downloading file ${filename}`);
-        let data = '';
-        client.get(filename, (err, stream) => {
-            if (err) return reject(err);
-            stream.once('close', () => resolve(data));
-            stream.on('data', chunk => {
-                data += chunk;
-            });
-            return undefined;
-        });
-    });
-
 const assertAppVersionIsValid = (
     latestAppVersion: string | undefined,
     app: App
@@ -234,39 +384,10 @@ const assertAppVersionIsValid = (
     }
 };
 
-type UploadLocalFile = (localFileName: string, remote: string) => Promise<void>;
-type UploadBufferContent = (content: Buffer, remote: string) => Promise<void>;
-
-const uploadFile: UploadLocalFile & UploadBufferContent = (
-    local: string | Buffer,
-    remote: string
-) =>
-    new Promise<void>((resolve, reject) => {
-        console.log(`Uploading file ${remote}`);
-        client.put(local, remote, err => (err ? reject(err) : resolve()));
-    });
-
-const createBlankSourceJson = async (name: string) => {
-    try {
-        await downloadFileContent('source.json');
-    } catch {
-        // Expected that the download throws an exception,
-        // because the file is supposed to not exist yet
-        return {
-            name,
-            apps: [],
-        };
-    }
-
-    throw new Error(
-        '`--create-source` given, but a `source.json` already exists on the server.'
-    );
-};
-
 const downloadSourceJson = async () => {
     let sourceJsonContent;
     try {
-        sourceJsonContent = await downloadFileContent('source.json');
+        sourceJsonContent = await client.download('source.json');
         const sourceJson = <SourceJson>JSON.parse(sourceJsonContent);
         if (
             sourceJson == null ||
@@ -292,15 +413,10 @@ const downloadSourceJson = async () => {
     }
 };
 
-const getUpdatedSourceJson = async (
-    app: App,
-    options: Options
-): Promise<SourceJson> => {
-    const sourceJson = await (options.doCreateSource
-        ? createBlankSourceJson(options.sourceName!) // eslint-disable-line @typescript-eslint/no-non-null-assertion -- Can never be null because of the control flow
-        : downloadSourceJson());
+const getUpdatedSourceJson = async (app: App): Promise<SourceJson> => {
+    const sourceJson = await downloadSourceJson();
     return {
-        name: sourceJson.name,
+        ...sourceJson,
         apps: [
             ...new Set(sourceJson.apps).add(
                 `${app.sourceUrl}/${app.appInfoName}`
@@ -313,7 +429,7 @@ const downloadExistingAppInfo = async (
     app: App
 ): Promise<Partial<Pick<AppInfo, 'latestVersion' | 'versions'>>> => {
     try {
-        const appInfoContent = await downloadFileContent(app.appInfoName);
+        const appInfoContent = await client.download(app.appInfoName);
         return JSON.parse(appInfoContent) as AppInfo;
     } catch (error) {
         console.log(
@@ -367,18 +483,19 @@ const getUpdatedAppInfo = async (app: App): Promise<AppInfo> => {
 };
 
 const uploadSourceJson = (sourceJson: SourceJson) =>
-    uploadFile(
+    client.uploadContent(
         Buffer.from(JSON.stringify(sourceJson, undefined, 2)),
         'source.json'
     );
 
 const uploadAppInfo = (app: App, appInfo: AppInfo) =>
-    uploadFile(
+    client.uploadContent(
         Buffer.from(JSON.stringify(appInfo, undefined, 2)),
         app.appInfoName
     );
 
-const uploadPackage = (app: App) => uploadFile(app.filename, app.filename);
+const uploadPackage = (app: App) =>
+    client.uploadLocalFile(app.filename, app.filename);
 
 const uploadChangelog = (app: App) => {
     const changelogFilename = 'Changelog.md';
@@ -387,7 +504,7 @@ const uploadChangelog = (app: App) => {
         return Promise.reject(new Error(errorMsg));
     }
 
-    return uploadFile(changelogFilename, app.releaseNotesFilename);
+    return client.uploadLocalFile(changelogFilename, app.releaseNotesFilename);
 };
 
 const uploadIcon = (app: App) => {
@@ -397,36 +514,27 @@ const uploadIcon = (app: App) => {
         return Promise.reject(new Error(errorMsg));
     }
 
-    return uploadFile(localIconFilename, app.iconFilename);
+    return client.uploadLocalFile(localIconFilename, app.iconFilename);
 };
 
 const main = async () => {
     try {
-        /*
-         * To use this script REPO_HOST, REPO_USER and REPO_PASS will need to be set
-         */
-        const config = {
-            host: process.env.REPO_HOST || 'localhost',
-            port: Number(process.env.REPO_PORT) || 21,
-            user: process.env.REPO_USER || 'anonymous',
-            password: process.env.REPO_PASS || 'anonymous@',
-        };
-
         const options = parseOptions();
 
+        client =
+            options.destination === 'ftp'
+                ? new FtpClient(options)
+                : new ArtifactoryClient(options);
+
         checkAppProperties({
             checkChangelogHasCurrentEntry: options.deployOfficial,
         });
 
         const app = packOrReadPackage(options);
 
-        await connect(config);
-        if (options.doCreateSource) {
-            await createSourceDirectory(options.sourceDir);
-        }
-        await changeWorkingDirectory(options.sourceDir);
+        await client.initialise(options);
 
-        const sourceJson = await getUpdatedSourceJson(app, options);
+        const sourceJson = await getUpdatedSourceJson(app);
         const appInfo = await getUpdatedAppInfo(app);
 
         await uploadChangelog(app);
@@ -441,7 +549,7 @@ const main = async () => {
         process.exitCode = 1;
     }
 
-    client.end();
+    client?.end();
 };
 
 main();

package/scripts/prepare-shared-release.ts

@@ -78,8 +78,8 @@ const updateChangelog = (nextReleaseNumber: string) => {
     }
 
     if (
-        header === 'Unreleased' ||
-        header === `${nextReleaseNumber} - Unreleased`
+        header.toLowerCase() === 'unreleased' ||
+        header.toLowerCase() === `${nextReleaseNumber} - unreleased`
     ) {
         writeFileSync(
             'Changelog.md',

package/src/About/DeviceCard.tsx

@@ -8,11 +8,7 @@ import React from 'react';
 import { useSelector } from 'react-redux';
 
 import Card from '../Card/Card';
-import {
-    buyOnlineUrl,
-    deviceInfo,
-    productPageUrl,
-} from '../Device/deviceInfo/deviceInfo';
+import { deviceInfo } from '../Device/deviceInfo/deviceInfo';
 import { selectedDevice, selectedDeviceInfo } from '../Device/deviceSlice';
 import AboutButton from './AboutButton';
 import Section from './Section';
@@ -38,7 +34,7 @@ export default () => {
     }
 
     const pca = device.devkit?.boardVersion;
-    const { name, cores } = deviceInfo(device);
+    const { name, cores, website } = deviceInfo(device);
 
     return (
         <Card title="Device">
@@ -61,13 +57,13 @@ export default () => {
 
                 <Section>
                     <AboutButton
-                        url={buyOnlineUrl(device)}
+                        url={website.buyOnline}
                         label="Find distributor"
                     />
                 </Section>
                 <Section>
                     <AboutButton
-                        url={productPageUrl(device)}
+                        url={website.productPage}
                         label="Go to product page"
                     />
                 </Section>