@my-devkit/cli 1.0.0 → 1.0.1

package/src/switch-to-npm.ts

@@ -0,0 +1,24 @@
+import { config, Npm } from './utils';
+
+const switchToNpm = async () => {
+    for (const pkg of config().packages) {
+        const npm = Npm.prefix(pkg.path);
+        await npm.clean();
+        await npm.write(['scripts', 'preinstall'], undefined);
+        await npm.install();
+
+        if (pkg.deploy) {
+            await npm.build();
+            await npm.publishIfNeeded();
+
+            const packageName = await npm.getName();
+            const newVersion = await npm.getPublishedVersion();
+
+            for (const otherPackage of config().packages) {
+                await Npm.prefix(otherPackage.path).updateDependency(packageName, newVersion);
+            }
+        }
+    }
+};
+
+export default switchToNpm;

package/src/switch-to-pnpm.ts

@@ -0,0 +1,19 @@
+import { config, Npm } from './utils';
+
+const switchToPnpm = async () => {
+    for (const pkg of config().packages) {
+        const npm = Npm.prefix(pkg.path);
+        await npm.clean();
+        await npm.removePackageLock();
+        await npm.write('version', '1.0.0');
+        await npm.write(['scripts', 'preinstall'], 'npx only-allow pnpm');
+
+        const packageName = await npm.getName();
+
+        for (const otherPackage of config().packages) {
+            await Npm.prefix(otherPackage.path).updateDependency(packageName, 'workspace:^1.0.0');
+        }
+    }
+};
+
+export default switchToPnpm;

package/src/utils/args.ts

@@ -0,0 +1,6 @@
+const _args = process.argv.filter(arg => arg.startsWith('-'))
+    .map((name) => ({ name, value: process.argv[process.argv.indexOf(name) + 1] }));
+
+export const args = (option: string, defaultValue: string = null): string => {
+    return _args.find(arg => arg.name === option)?.value || defaultValue;
+}

package/src/utils/config.ts

@@ -0,0 +1,25 @@
+import * as fs from 'fs';
+
+interface ConfigPackageFileReplacement {
+    replace: string;
+    with: string;
+}
+
+interface ConfigPackage {
+    path: string;
+    deploy: boolean;
+    tokensReplacements?: string[];
+    fileReplacements?: ConfigPackageFileReplacement[];
+}
+
+interface Config {
+    packages: ConfigPackage[];
+}
+
+export const config = (): Config => {
+    if (!fs.existsSync('./my-devkit.json')) {
+        throw new Error('File my-devkit.json not found!');
+    }
+
+    return JSON.parse(fs.readFileSync('./my-devkit.json', { encoding: 'utf-8' }));
+}

package/src/utils/gist.ts

@@ -0,0 +1,62 @@
+import got from 'got';
+
+export class Gist {
+    static username = 'BUONJG';
+    static password = '7a3f262a616ad6613a30755a6285d4b313603b36';
+    static gistId = 'b22c85715f2c52e7a4f157a91030ff14';
+
+    static async getPackages(): Promise<Gist.Packages> {
+        const response = await got<Gist.Gist>(`https://api.github.com/gists/${Gist.gistId}`, {
+            method: 'GET',
+            username: Gist.username,
+            password: Gist.password,
+            responseType: 'json'
+        });
+
+        return JSON.parse(response.body.files.packages.content) || {};
+    }
+
+
+    static async getPackageChecksum(packageName) {
+        const packages = await Gist.getPackages();
+
+        return packages[packageName] || null;
+    }
+
+    static async setPackageChecksum(packageName, checksum) {
+        const packages = await Gist.getPackages();
+        packages[packageName] = checksum;
+
+        await got(`https://api.github.com/gists/${Gist.gistId}`, {
+            method: 'PATCH',
+            username: Gist.username,
+            password: Gist.password,
+            json: {
+                files: {
+                    file: {
+                        filename: "packages",
+                        type: "application/json",
+                        content: JSON.stringify(packages, null, 4)
+                    }
+                }
+            }
+        });
+    }
+}
+
+export namespace Gist {
+    export interface Gist {
+        files: {
+            [key: string]: {
+                filename: string;
+                size: number;
+                truncated: boolean;
+                content: string;
+            }
+        }
+    }
+
+    export interface Packages {
+        [key: string]: string;
+    }
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export * from './args';
+export * from './config';
+export * from './npm';
+export * from './gist';

package/src/utils/npm.ts

@@ -0,0 +1,164 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+
+import { Gist } from './gist';
+
+export class Npm {
+    private _verbose = false;
+
+    constructor(private prefix: string) {
+    }
+
+    static prefix(prefix: string) {
+        return new Npm(prefix);
+    }
+
+    public verbose(verbose = true): void {
+        this._verbose = verbose;
+    }
+
+    public async publishIfNeeded(): Promise<void> {
+        await this.write('version', await this.getPublishedVersion());
+
+        const localCheckSum = await this.getLocalChecksum();
+        const remoteCheckSum = await this.getRemoteChecksum();
+
+        if (localCheckSum === remoteCheckSum) {
+            console.log(`Package ${await this.getName()} is already up to date!`);
+            return;
+        }
+
+        await this.patch();
+
+        await this.publish();
+
+        await this.updateRemoteChecksum();
+
+        console.log(`Package ${await this.getName()} ${await this.getLocalVersion()} as been published!`);
+    }
+
+    public async clean(): Promise<void> {
+        this.log(`Remove ${this.prefix}/node_modules`);
+        if (fs.existsSync(`${this.prefix}/node_modules`)) {
+            fs.rmSync(`${this.prefix}/node_modules`, { recursive: true, force: true });
+        }
+
+        this.log(`Remove ${this.prefix}/dist`);
+        if (fs.existsSync(`${this.prefix}/dist`)) {
+            fs.rmSync(`${this.prefix}/dist`, { recursive: true, force: true });
+        }
+        fs.mkdirSync(`${this.prefix}/dist`);
+    }
+
+    public async removePackageLock(): Promise<void> {
+        if (fs.existsSync(`${this.prefix}/package-lock.json`)) {
+            fs.rmSync(`${this.prefix}/package-lock.json`);
+        }
+    }
+
+    public async install(): Promise<void> {
+        this.log('Install package dependencies');
+        await this.execCmd(`npm install --prefix=${this.prefix} --silent`);
+    }
+
+    public async build(): Promise<void> {
+        this.log('Build package');
+        await this.execCmd(`npm run build --prefix=${this.prefix} --silent`);
+    }
+
+    public async patch(): Promise<void> {
+        this.log(`Patch ${await this.getName()}: ${await this.getLocalVersion()}`);
+        await this.execCmd(`npm version patch --prefix=${this.prefix}`);
+        this.log(`New version is: ${await this.getLocalVersion()}`);
+    }
+
+    public async publish(): Promise<void> {
+        this.log(`Publish ${await this.getName()}: ${await this.getLocalVersion()}`);
+        await this.execCmd(`cd ${this.prefix} && npm publish --access public --silent`);
+    }
+
+    public async getName(): Promise<string> {
+        return this.read('name');
+    }
+
+    public async getLocalVersion(): Promise<string> {
+        return this.read('version');
+    }
+
+    public async getPublishedVersion(): Promise<string> {
+        const packageName = await this.getName();
+        return this.execCmd(`npm show ${packageName} version`);
+    }
+
+    public async getLocalChecksum(): Promise<string> {
+        await this.execCmd(`cd ${this.prefix} && npx checksum ./dist/* ./src/* > checksum.txt`);
+        const checkSum = (await this.execCmd(`npx checksum ${this.prefix}/checksum.txt`)).split(' ')[0];
+        fs.unlinkSync(`${this.prefix}/checksum.txt`);
+
+        return checkSum;
+    }
+
+    public async getRemoteChecksum(): Promise<string> {
+        const packageName = await this.getName();
+
+        return Gist.getPackageChecksum(packageName);
+    }
+
+    public async updateRemoteChecksum(): Promise<void> {
+        const packageName = await this.getName();
+        const checksum = await this.getLocalChecksum();
+
+        this.log(`Set new package checksum: ${packageName} = ${checksum}`);
+
+        await Gist.setPackageChecksum(packageName, checksum);
+    }
+
+    public async updateDependency(packageName: string, newVersion: string): Promise<void> {
+        for (const dependency of ['dependencies', 'devDependencies', 'peerDependencies']) {
+            const currentVersion = await this.read([dependency, packageName]);
+            if (currentVersion) {
+                await this.write([dependency, packageName], newVersion);
+            }
+        }
+    }
+
+    public async read(properties: string | string[]): Promise<string> {
+        properties = Array.isArray(properties) ? properties : [properties];
+
+        let object = JSON.parse(fs.readFileSync(`${this.prefix}/package.json`, 'utf8'));
+
+        let index = 0;
+        while (object != null && index < properties.length) {
+            object = object[properties[index++]]
+        }
+        return object;
+    }
+
+    public async write(properties: string | string[], value: string): Promise<void> {
+        properties = Array.isArray(properties) ? properties : [properties];
+
+        this.log(`Write ${properties.join('->')} = ${value} in ${this.prefix}/package.json`);
+
+        const data = JSON.parse(fs.readFileSync(`${this.prefix}/package.json`, 'utf8'));
+
+        let object = data; let index = 0;
+        while (object != null && index < (properties.length - 1)) {
+            object = object[properties[index++]]
+        }
+        object[properties[properties.length - 1]] = value;
+
+        fs.writeFileSync(`${this.prefix}/package.json`, JSON.stringify(data, null, 4));
+    }
+
+    private async execCmd(cmd: string): Promise<string> {
+        const response = execSync(cmd, {});
+        return response.toString().trim();
+    }
+
+    private log(...messages) {
+        if (this._verbose) {
+            console.log('   - ', ...messages);
+        }
+    }
+}
+

package/tsconfig.json

@@ -17,4 +17,4 @@
             "node_modules/@types"
         ]
     }
-}
+}