@stackbit/cms-core 0.1.25 → 0.1.26-develop.1

package/src/services/git.ts

@@ -0,0 +1,245 @@
+import _ from 'lodash';
+import os from 'os';
+import path from 'path';
+import { v4 as uuid } from 'uuid';
+import fse from 'fs-extra';
+
+import { GitServiceInterface, GitFileCommitDescriptor, GitAuthor, GitCommitLogEntry, Logger } from '@stackbit/types';
+import { Worker } from '@stackbit/utils';
+
+import { DocumentStatus } from '@stackbit/types';
+import { CommandRunner } from '@stackbit/types';
+
+const GIT_LOG_CHANGE_TYPES: Record<string, DocumentStatus> = {
+    M: 'modified',
+    A: 'added',
+    D: 'deleted'
+};
+
+export class GitService implements GitServiceInterface {
+    private readonly repoUrl: string;
+    private readonly repoDir: string;
+    private readonly repoBranch: string;
+    private readonly repoPublishBranch: string;
+    private readonly worker: Worker;
+    private readonly runCommand: CommandRunner;
+    private readonly logger: Logger;
+    private readonly userLogger: Logger;
+
+    private branchFetched: boolean = false;
+
+    constructor(options: {
+        repoUrl: string;
+        repoDir: string;
+        repoBranch: string;
+        repoPublishBranch: string;
+        worker: Worker;
+        runCommand: CommandRunner;
+        logger: Logger;
+        userLogger: Logger;
+    }) {
+        this.repoUrl = options.repoUrl;
+        this.repoDir = options.repoDir;
+        this.repoBranch = options.repoBranch;
+        this.repoPublishBranch = options.repoPublishBranch;
+        this.worker = options.worker;
+        this.runCommand = options.runCommand;
+        this.logger = options.logger;
+        this.userLogger = options.userLogger;
+    }
+
+    getRepoUrl() {
+        return this.repoUrl;
+    }
+
+    getRepoBranch() {
+        return this.repoBranch;
+    }
+
+    getRepoPublishBranch() {
+        return this.repoPublishBranch;
+    }
+
+    private async commit(author: GitAuthor, files: GitFileCommitDescriptor[]) {
+        const filePaths = _.map(files, 'filePath');
+        this.logger.debug('[git] Commit scheduled', filePaths);
+        return this.worker.schedule(async () => {
+            this.logger.debug('[git] Commit running', filePaths);
+            const message = files
+                .reduce((messages: string[], file) => {
+                    messages.push(`${path.parse(file.filePath).base}: ${file.description}`);
+                    return messages;
+                }, [])
+                .join('.\n');
+            await this.runCommand('git', ['add', ...filePaths], { cwd: this.repoDir });
+            await this.runCommand('git', ['commit', '--no-verify', '--author', `${author.name || author.email} <${author.email}>`, '-m', message], {
+                cwd: this.repoDir
+            });
+            this.logger.debug('[git] Commit done', filePaths);
+        });
+    }
+
+    private push() {
+        this.logger.debug('[git] Push scheduled');
+        return this.worker.schedule(async () => {
+            this.logger.debug('[git] Push running');
+            await this.runCommand('rm', ['-rf', '.git/rebase-merge'], { cwd: this.repoDir }).catch((err) => {}); // fixes leftover rebase directory with autostash
+            await this.runCommand('git', ['pull', 'origin', this.repoBranch, '--rebase', '--autostash', '-Xtheirs'], { cwd: this.repoDir });
+            await this.runCommand('git', ['push', 'origin', this.repoBranch], { cwd: this.repoDir });
+            this.logger.debug('[git] Push done');
+        });
+    }
+
+    async commitAndPush(author: GitAuthor, files: GitFileCommitDescriptor[]): Promise<void> {
+        await this.commit(author, files);
+        return this.push();
+    }
+
+    pull(): Promise<void> {
+        this.logger.debug('[git] Pull scheduled');
+        return this.worker.schedule(async () => {
+            this.logger.debug('[git] Pull running');
+            await this.runCommand('git', ['pull', 'origin', '--rebase', '--autostash', '-Xtheirs'], { cwd: this.repoDir });
+            this.logger.debug('[git] Pull done');
+        });
+    }
+
+    private async publishAll(author: GitAuthor) {
+        this.logger.debug('[git] Publish all started');
+        const publishDir = path.join(os.tmpdir(), uuid());
+        await this.runCommand('git', ['clone', this.repoUrl, '--branch', this.repoPublishBranch, publishDir]);
+        try {
+            await this.runCommand('git', ['merge', `origin/${this.repoBranch}`, this.repoPublishBranch, '-Xtheirs'], { cwd: publishDir });
+            await this.runCommand('git', ['commit', '--author', `${author.name || author.email} <${author.email}>`, `-m`, 'Publish'], {
+                cwd: publishDir
+            }).catch(() => {});
+            await this.runCommand('git', ['push', 'origin'], { cwd: publishDir });
+        } finally {
+            await fse.remove(publishDir);
+        }
+        this.logger.debug('[git] Publish all done');
+    }
+
+    private async publishFiles(author: GitAuthor, filePaths: string[]) {
+        this.logger.debug('[git] Publish files started', filePaths);
+        const publishDir = path.join(os.tmpdir(), uuid());
+        await this.runCommand('git', ['clone', this.repoUrl, '--branch', this.repoPublishBranch, publishDir]);
+        try {
+            await Promise.all(
+                filePaths.map(async (filePath) => {
+                    const destFilePath = path.join(publishDir, filePath);
+                    await fse.ensureDir(path.dirname(destFilePath));
+                    return fse.copy(path.join(this.repoDir, filePath), destFilePath);
+                })
+            );
+
+            await this.runCommand('git', ['checkout', '-b', 'stackbit-publish-branch'], { cwd: publishDir });
+            await this.runCommand('git', ['add', ...filePaths], { cwd: publishDir });
+            await this.runCommand('git', ['commit', '--author', `${author.name || author.email} <${author.email}>`, `-m`, 'Publish'], {
+                cwd: publishDir
+            }).catch((err) => {
+                return;
+            });
+
+            await this.runCommand('git', ['checkout', this.repoBranch], { cwd: publishDir });
+            await this.runCommand('git', ['merge', 'stackbit-publish-branch', this.repoBranch, '-Xtheirs'], { cwd: publishDir });
+
+            await this.runCommand('git', ['checkout', this.repoPublishBranch], { cwd: publishDir });
+            await this.runCommand('git', ['merge', 'stackbit-publish-branch', this.repoPublishBranch, '-Xtheirs'], { cwd: publishDir });
+
+            await this.runCommand('git', ['push', 'origin', this.repoPublishBranch, this.repoBranch], { cwd: publishDir });
+        } finally {
+            await fse.remove(publishDir);
+        }
+        this.logger.debug('[git] Publish files done', filePaths);
+    }
+
+    publish(author: GitAuthor, filePaths?: string[]): Promise<void> {
+        this.logger.debug('[git] Publish scheduled');
+        return this.worker.schedule(async () => {
+            if (filePaths) {
+                if (!filePaths.length) {
+                    this.logger.debug('[git] Nothing to publish');
+                    return;
+                }
+                return this.publishFiles(author, filePaths);
+            } else {
+                return this.publishAll(author);
+            }
+        });
+    }
+
+    private parseGitCommitAuthor(author?: string) {
+        if (!author) {
+            return author;
+        }
+        const regex = /(.*)\((.*)\)/;
+        const match = author.match(regex);
+        if (match) {
+            const [authorEmail, authorName] = match.slice(1);
+
+            if (authorName === 'Stackbit Code Editor') {
+                return 'stackbit';
+            }
+            return authorEmail ? authorEmail.toLowerCase() : author;
+        }
+        return author;
+    }
+
+    async diff(): Promise<string[]> {
+        this.logger.debug('[git] Diff check scheduled');
+        return this.worker.schedule(async () => {
+            this.logger.debug('[git] Diff check running');
+            const result = await this.runCommand(
+                'git',
+                [
+                    'diff',
+                    '--name-only',
+                    '--no-renames', // this flag makes sure we get both old and new name of renamed file
+                    `origin/${this.repoPublishBranch}..${this.repoBranch}`
+                ],
+                { cwd: this.repoDir }
+            );
+            this.logger.debug('[git] Diff check done');
+            return result.stdout.split('\n').filter(Boolean);
+        });
+    }
+
+    async commitLog(): Promise<GitCommitLogEntry[]> {
+        this.logger.debug('[git] Changes check scheduled');
+        return this.worker.schedule(async () => {
+            this.logger.debug('[git] Changes check running');
+            if (!this.branchFetched) {
+                await this.runCommand('git', ['fetch', 'origin', `${this.repoPublishBranch}:${this.repoPublishBranch}`], { cwd: this.repoDir });
+                this.branchFetched = true;
+            }
+            const logResult = await this.runCommand(
+                'git',
+                ['log', '--pretty=format:commit:%H%n%at%n%ae%x28%an%x29', '--name-status', `${this.repoPublishBranch}..${this.repoBranch}`],
+                { cwd: this.repoDir }
+            );
+            this.logger.debug('[git] Changes check done');
+            return logResult.stdout
+                .split('commit:')
+                .filter(Boolean)
+                .map((rawCommit) => {
+                    const split = rawCommit.trim().split('\n');
+                    return {
+                        author: this.parseGitCommitAuthor(split[2]),
+                        timestamp: split[1] ? new Date(parseInt(split[1]) * 1000) : undefined,
+                        commitHash: split[0],
+                        changes: split
+                            .slice(3)
+                            .map((line) => line.trim().split(/\t/))
+                            .filter(Boolean)
+                            .filter(([status, filename]) => status && filename)
+                            .map(([status, filename]) => ({
+                                status: GIT_LOG_CHANGE_TYPES[status!] || 'modified',
+                                filePath: filename
+                            }))
+                    };
+                })
+                .reverse();
+        });
+    }
+}

package/src/services/index.ts

@@ -0,0 +1,2 @@
+export * from './run';
+export * from './git';

package/src/services/run.ts

@@ -0,0 +1,54 @@
+import childProcess, { ChildProcessWithoutNullStreams } from 'child_process';
+import { CommandRunner, RunResult } from '@stackbit/types';
+
+export function getCommandRunner(commandRunnerOptions: { env: NodeJS.ProcessEnv; uid?: number }): CommandRunner {
+    return (command: string, args?: string[], options?: { cwd?: string; shell?: boolean; env?: NodeJS.ProcessEnv }): Promise<RunResult> => {
+        return getProcessPromise(
+            childProcess.spawn(command, args, {
+                cwd: options?.cwd,
+                shell: options?.shell,
+                env: {
+                    ...commandRunnerOptions.env,
+                    ...options?.env
+                },
+                ...(commandRunnerOptions.uid ? { uid: commandRunnerOptions.uid } : {})
+            })
+        );
+    }
+}
+
+function getProcessPromise(p: ChildProcessWithoutNullStreams): Promise<{
+    stdout: string;
+    stderr: string;
+    exitCode?: number;
+    err?: Error;
+}> {
+    return new Promise((resolve, reject) => {
+        let stdout = '';
+        let stderr = '';
+        p.stdout.on('data', (out) => (stdout += out));
+        p.stderr.on('data', (out) => (stderr += out));
+        p.on('exit', (exitCode) => {
+            if (exitCode !== 0) {
+                reject({
+                    err: new Error(`process exited with code: ${exitCode}, stderr: ${stderr}`),
+                    stdout,
+                    stderr,
+                    exitCode
+                });
+            } else {
+                resolve({
+                    stdout,
+                    stderr
+                });
+            }
+        });
+        p.on('error', (err) => {
+            reject({
+                err,
+                stdout,
+                stderr
+            });
+        });
+    });
+}