@adinsure-ops/ops-cli 4.0.0-rc10

package/lib/commands/npm/check-publish.d.ts

@@ -0,0 +1,16 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+import { AzurePackageArray, NpmPackage } from '../../types/npm.types';
+export default class NpmCheckPublish extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        package: flags.IOptionFlag<string[]>;
+        exclude: flags.IOptionFlag<string[]>;
+        version: flags.IOptionFlag<string>;
+        pat: flags.IOptionFlag<string | undefined>;
+    };
+    checkPackagesExists(packages: NpmPackage[], allPackages: AzurePackageArray, version: string): Promise<void>;
+    run(): Promise<void>;
+}

package/lib/commands/npm/check-publish.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const cli_ux_1 = require("cli-ux");
+const command_base_1 = require("../../command.base");
+const npm_1 = require("../../lib/npm");
+class NpmCheckPublish extends command_base_1.default {
+    async checkPackagesExists(packages, allPackages, version) {
+        let errorCount = 0;
+        for (const pkg of packages) {
+            cli_ux_1.default.action.start(`${pkg.name}@${version}`, undefined, { stdout: true });
+            let matchedPackage = allPackages.value.find(azurePackage => azurePackage.name === pkg.name);
+            if (!matchedPackage) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red('package missing')}`);
+                errorCount++;
+                continue;
+            }
+            let matchVersion = matchedPackage.versions.find(azurePackageVersion => azurePackageVersion.version === version);
+            if (!matchVersion) {
+                cli_ux_1.default.action.stop(`${chalk_1.default.red('version missing')}`);
+                errorCount++;
+                continue;
+            }
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('exists')}`);
+        }
+        if (errorCount > 0) {
+            throw new Error(`${errorCount} packages or versions missing!`);
+        }
+    }
+    async run() {
+        try {
+            const { flags } = this.parse(NpmCheckPublish);
+            let npmContext = new npm_1.default();
+            cli_ux_1.default.action.start('Parsing packages to check', undefined, { stdout: true });
+            const packages = await npmContext.packageList(flags.package, flags.exclude, this);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            cli_ux_1.default.action.start('Getting list of available packages', undefined, { stdout: true });
+            const allPackages = JSON.parse(await npmContext.getAllNpmPackages(flags.pat));
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            await this.checkPackagesExists(packages, allPackages, flags.version);
+            cli_ux_1.default.action.stop('success');
+        }
+        catch (err) {
+            cli_ux_1.default.action.stop('error');
+            this.error(`${err.message}`);
+        }
+    }
+}
+exports.default = NpmCheckPublish;
+NpmCheckPublish.description = 'check if npm packages were published';
+NpmCheckPublish.usage = 'npm:check-publish [options]';
+NpmCheckPublish.examples = [
+    '$ ops npm:check-publish -v 6.0.1',
+    '$ ops npm:check-publish -p @adinsure/* -v 6.0.0',
+    '$ ops npm:check-publish -p @adinsure/* -x @adisure/demo -v 6.0.0'
+];
+NpmCheckPublish.flags = {
+    package: command_1.flags.string({
+        char: 'p',
+        description: 'package name filter you want to check',
+        multiple: true
+    }),
+    exclude: command_1.flags.string({
+        char: 'x',
+        description: 'exclude packages from filter',
+        multiple: true
+    }),
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'version we want to check if published',
+        required: true
+    }),
+    pat: command_1.flags.string({
+        description: 'PAT token or AZURE_DEVOPS_EXT_PAT environment variable'
+    }),
+};

package/lib/commands/npm/publish.d.ts

@@ -0,0 +1,22 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../../command.base';
+import { AzurePackageArray, NpmPackage } from '../../types/npm.types';
+export default class NpmPublish extends CommandBase {
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        package: flags.IOptionFlag<string[]>;
+        exclude: flags.IOptionFlag<string[]>;
+        version: flags.IOptionFlag<string>;
+        pat: flags.IOptionFlag<string | undefined>;
+    };
+    private cp;
+    publishPackage(pkg: NpmPackage, cmd?: string[]): Promise<{
+        data: string;
+        error: string;
+    }>;
+    checkPackageCanPublish(pkg: NpmPackage, allPackages: AzurePackageArray, version: string): Promise<boolean>;
+    publishPackages(packages: NpmPackage[], allPackages: AzurePackageArray, version: string): Promise<void>;
+    run(): Promise<void>;
+}

package/lib/commands/npm/publish.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const command_1 = require("@oclif/command");
+const chalk_1 = require("chalk");
+const child_process_1 = require("child_process");
+const cli_ux_1 = require("cli-ux");
+const command_base_1 = require("../../command.base");
+const npm_1 = require("../../lib/npm");
+class NpmPublish extends command_base_1.default {
+    async publishPackage(pkg, cmd = ['yarn', 'publish']) {
+        var e_1, _a, e_2, _b;
+        let sh;
+        let args;
+        // cross platform compatibility
+        if (process.platform === 'win32') {
+            sh = 'cmd';
+            args = ['/c'].concat(cmd);
+        }
+        else {
+            [sh, ...args] = cmd;
+        }
+        try {
+            this.cp = child_process_1.spawn(sh, args, {
+                cwd: pkg.path,
+                env: Object.assign(Object.assign({}, process.env), process.stdout.isTTY ? { FORCE_COLOR: process.env.FORCE_COLOR || '1' } : {}),
+                stdio: 'pipe'
+            });
+            let data = '';
+            try {
+                for (var _c = tslib_1.__asyncValues(this.cp.stdout), _d; _d = await _c.next(), !_d.done;) {
+                    const chunk = _d.value;
+                    data += chunk;
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_d && !_d.done && (_a = _c.return)) await _a.call(_c);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+            let error = '';
+            try {
+                for (var _e = tslib_1.__asyncValues(this.cp.stderr), _f; _f = await _e.next(), !_f.done;) {
+                    const chunk = _f.value;
+                    error += chunk;
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (_f && !_f.done && (_b = _e.return)) await _b.call(_e);
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+            const exitCode = await new Promise((resolve, _reject) => {
+                this.cp.on('close', resolve);
+            });
+            if (exitCode) {
+                throw new Error(`subprocess error exit ${exitCode}, ${error}`);
+            }
+            return { data, error };
+        }
+        catch (err) {
+            throw new Error(err.message);
+        }
+    }
+    async checkPackageCanPublish(pkg, allPackages, version) {
+        this.log('');
+        cli_ux_1.default.action.start(`${pkg.name}@${pkg.version}`, undefined, { stdout: true });
+        let matchedPackage = allPackages.value.find(azurePackage => azurePackage.name === pkg.name);
+        if (pkg.version !== version) {
+            this.warn(`${pkg.name}@${pkg.version} doesn't match desired publish version!`);
+            cli_ux_1.default.action.stop(chalk_1.default.red(`version doesn't match version ${version}`));
+            throw new Error(`Version in package.json doesn't match desired published version`);
+        }
+        if (!matchedPackage) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('new package')}`);
+            cli_ux_1.default.action.start(`publish new package ${pkg.name}@${pkg.version} from ${pkg.jsonPath}`, undefined, { stdout: true });
+            await this.publishPackage(pkg);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            return true;
+        }
+        let matchVersion = matchedPackage.versions.find(azurePackageVersion => azurePackageVersion.version === pkg.version);
+        if (!matchVersion) {
+            cli_ux_1.default.action.stop(`${chalk_1.default.yellow('version missing')}`);
+            cli_ux_1.default.action.start(`publish new version ${pkg.name}@${pkg.version} from ${pkg.jsonPath}`, undefined, { stdout: true });
+            await this.publishPackage(pkg);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            return true;
+        }
+        this.warn(`${pkg.name}@${pkg.version} already exists`);
+        cli_ux_1.default.action.stop(`${chalk_1.default.blue('skipping')}`);
+        return false;
+    }
+    async publishPackages(packages, allPackages, version) {
+        let errorCount = 0;
+        this.log(`publishing ${packages.length} packages:`);
+        this.log(packages.map(pkg => pkg.name).toString());
+        for (const pkg of packages) {
+            try {
+                await this.checkPackageCanPublish(pkg, allPackages, version);
+            }
+            catch (_a) {
+                errorCount++;
+                continue;
+            }
+        }
+        if (errorCount > 0) {
+            throw new Error(`${errorCount} with Errors!`);
+        }
+    }
+    async run() {
+        try {
+            const { flags } = this.parse(NpmPublish);
+            let npmContext = new npm_1.default();
+            cli_ux_1.default.action.start('Parsing packages to check', undefined, { stdout: true });
+            const packages = await npmContext.packageList(flags.package, flags.exclude, this);
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            cli_ux_1.default.action.start('Getting list of published packages', undefined, { stdout: true });
+            const allPackages = JSON.parse(await npmContext.getAllNpmPackages(flags.pat));
+            cli_ux_1.default.action.stop(`${chalk_1.default.green('done')}`);
+            await this.publishPackages(packages, allPackages, flags.version);
+            cli_ux_1.default.action.stop('success');
+        }
+        catch (err) {
+            cli_ux_1.default.action.stop('error');
+            this.error(`${err.message}`);
+        }
+    }
+}
+exports.default = NpmPublish;
+NpmPublish.description = 'Publish npm packages';
+NpmPublish.usage = 'npm:publish [options]';
+NpmPublish.examples = [
+    '$ ops npm:publish -v 15.0.0',
+    '$ ops npm:publish -v 15.0.0',
+    '$ ops npm:publish -p @adinsure-tooling/* -v 15.0.0',
+    '$ ops npm:publish -p @adinsure-tooling/* -x @adisure-tooling/studio-services -v 6.0.0'
+];
+NpmPublish.flags = {
+    package: command_1.flags.string({
+        char: 'p',
+        description: 'package name filter you want to check',
+        multiple: true
+    }),
+    exclude: command_1.flags.string({
+        char: 'x',
+        description: 'exclude packages from filter',
+        multiple: true
+    }),
+    version: command_1.flags.string({
+        char: 'v',
+        description: 'version we want to check if published',
+        required: true
+    }),
+    pat: command_1.flags.string({
+        description: 'PAT token or AZURE_DEVOPS_EXT_PAT environment variable',
+        env: 'AZURE_DEVOPS_EXT_PAT'
+    }),
+};

package/lib/commands/prepare-content.d.ts

@@ -0,0 +1,29 @@
+import { flags } from '@oclif/command';
+import CommandBase from '../command.base';
+interface Transformation {
+    name: string;
+    srcPath: string;
+    transform(): void;
+}
+interface DotfileLine {
+    prefix: string;
+    source: string;
+    transformData: string;
+}
+export default class PrepareContent extends CommandBase {
+    static readonly dotfile = ".opsprepare";
+    static description: string;
+    static usage: string;
+    static examples: string[];
+    static flags: {
+        destination: flags.IOptionFlag<string>;
+        source: flags.IOptionFlag<string>;
+    };
+    parseDotfileLine(line: string, sourceDirectory: string): Promise<DotfileLine>;
+    readDotfile(sourceDirectory: string): Promise<DotfileLine[]>;
+    getTransformation(lineData: DotfileLine, baseSourcedir: string, baseDestinationDir: string): Promise<Transformation>;
+    prepareTransformations(linesData: DotfileLine[], baseSourceDir: string, baseDestinationDir: string): Promise<Transformation[]>;
+    runTransformations(transformations: Transformation[]): Promise<void>;
+    run(): Promise<void>;
+}
+export {};