@my-devkit/cli 1.0.0 → 1.0.4

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,5 @@
+export * from './args';
+export * from './config';
+export * from './npm';
+export * from './gist';
+export * from './file-system';

package/src/utils/npm.ts

@@ -0,0 +1,163 @@
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+
+import { FileSystem } from './file-system';
+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(remoteCheckSum);
+
+        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> {
+        const version = await this.read('version');
+        await this.write('version', '1.0.1');
+        const checksum = FileSystem.getChecksum([`${this.prefix}/dist`, `${this.prefix}/src`, `${this.prefix}/package.json`]);
+        await this.write('version', version);
+        return checksum;
+    }
+
+    public async getRemoteChecksum(): Promise<string> {
+        const packageName = await this.getName();
+
+        return Gist.getPackageChecksum(packageName);
+    }
+
+    public async updateRemoteChecksum(checksum: string): Promise<void> {
+        const packageName = await this.getName();
+        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"
         ]
     }
-}
+}