@stackbit/cms-core 0.1.25-cloudinary-presets.0 → 0.1.26-develop.0

package/dist/utils/store-to-csi-docs-converter.d.ts

@@ -1,4 +1,4 @@
 import * as CSITypes from '@stackbit/types';
-import * as ContentStoreTypes from '../content-store-types';
+import * as ContentStoreTypes from '../types';
 export declare function mapStoreDocumentsToCSIDocumentsWithSource(documents: ContentStoreTypes.Document[]): CSITypes.DocumentWithSource[];
 //# sourceMappingURL=store-to-csi-docs-converter.d.ts.map

package/dist/utils/store-to-csi-docs-converter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"store-to-csi-docs-converter.d.ts","sourceRoot":"","sources":["../../src/utils/store-to-csi-docs-converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,iBAAiB,MAAM,wBAAwB,CAAC;AAE5D,wBAAgB,yCAAyC,CAAC,SAAS,EAAE,iBAAiB,CAAC,QAAQ,EAAE,GAAG,QAAQ,CAAC,kBAAkB,EAAE,CAEhI"}
+{"version":3,"file":"store-to-csi-docs-converter.d.ts","sourceRoot":"","sources":["../../src/utils/store-to-csi-docs-converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,iBAAiB,MAAM,UAAU,CAAC;AAE9C,wBAAgB,yCAAyC,CAAC,SAAS,EAAE,iBAAiB,CAAC,QAAQ,EAAE,GAAG,QAAQ,CAAC,kBAAkB,EAAE,CAEhI"}

package/dist/utils/timer.d.ts

@@ -1,4 +1,4 @@
-import { Logger } from '../content-store-types';
+import { Logger } from '@stackbit/types';
 export declare class Timer {
     private readonly timerCallback;
     private readonly timerMs;

package/dist/utils/timer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/utils/timer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD,qBAAa,KAAK;IACd,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAa;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,OAAO,CAAwB;gBAE3B,EAAE,aAAa,EAAE,OAAwB,EAAE,MAAM,EAAE,EAAE;QAAE,aAAa,EAAE,MAAM,IAAI,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;IAQjI,SAAS;IAIT,UAAU;IAIV,UAAU;IAKV,SAAS;IAOT,aAAa;CAKhB"}
+{"version":3,"file":"timer.d.ts","sourceRoot":"","sources":["../../src/utils/timer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AAEzC,qBAAa,KAAK;IACd,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAa;IAC3C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;IACjC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAS;IACjC,OAAO,CAAC,OAAO,CAAwB;gBAE3B,EAAE,aAAa,EAAE,OAAwB,EAAE,MAAM,EAAE,EAAE;QAAE,aAAa,EAAE,MAAM,IAAI,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAA;KAAE;IAQjI,SAAS;IAIT,UAAU;IAIV,UAAU;IAKV,SAAS;IAOT,aAAa;CAKhB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stackbit/cms-core",
-  "version": "0.1.25-cloudinary-presets.0",
+  "version": "0.1.26-develop.0",
   "description": "stackbit-dev",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,8 +18,10 @@
   "author": "Stackbit Inc.",
   "license": "MIT",
   "devDependencies": {
+    "@types/fs-extra": "^11.0.1",
     "@types/jest": "^27.5.2",
     "@types/lodash": "^4.14.182",
+    "@types/uuid": "^9.0.0",
     "jest": "^27.4.7",
     "prettier": "^2.5.1",
     "ts-jest": "^27.1.3",
@@ -29,9 +31,9 @@
     "@babel/parser": "^7.11.5",
     "@babel/traverse": "^7.11.5",
     "@iarna/toml": "^2.2.3",
-    "@stackbit/sdk": "^0.3.18-cloudinary-presets.0",
-    "@stackbit/types": "^0.1.11-cloudinary-presets.0",
-    "@stackbit/utils": "^0.2.17-cloudinary-presets.0",
+    "@stackbit/sdk": "0.3.19-develop.0",
+    "@stackbit/types": "0.1.11-develop.0",
+    "@stackbit/utils": "0.2.18-develop.0",
     "chalk": "^4.0.1",
     "esm": "^3.2.25",
     "fs-extra": "^8.1.0",
@@ -43,7 +45,8 @@
     "moment": "^2.29.1",
     "parse5": "^6.0.1",
     "sanitize-filename": "^1.6.3",
-    "slugify": "^1.6.5"
+    "slugify": "^1.6.5",
+    "uuid": "^9.0.0"
   },
-  "gitHead": "0df21f02c731c795a86e7de349dcd910063a8779"
+  "gitHead": "d2032e3174de3c2c1b853198d3a2601a6482b68c"
 }

package/src/content-store-utils.ts

@@ -3,8 +3,7 @@ import { Model } from '@stackbit/sdk';
 import { append } from '@stackbit/utils';
 import { Field, FieldList, FieldListItems, FieldListProps, FieldObjectProps, FieldSpecificProps, FieldType, UpdateOperationValueField } from '@stackbit/types';
 import * as CSITypes from '@stackbit/types';
-import * as ContentStoreTypes from './content-store-types';
-import { CrossReferenceData } from './content-store-types';
+import * as ContentStoreTypes from './types';
 
 export function getContentSourceIdForContentSource(contentSource: CSITypes.ContentSourceInterface): string {
     return getContentSourceId(contentSource.getContentSourceType(), contentSource.getProjectId());
@@ -15,10 +14,22 @@ export function getContentSourceId(contentSourceType: string, srcProjectId: stri
 }
 
 export function getUserContextForSrcType(srcType: string, user?: ContentStoreTypes.User): unknown {
-    return user?.connections?.find((connection) => connection.type === srcType);
+    if (!user) {
+        return user;
+    }
+    const connection = user?.connections?.find((connection) => connection.type === srcType);
+    return {
+        email: user.email,
+        name: user.name,
+        ...connection
+    };
+}
+
+export function isDocumentFieldOneOfFieldTypes<T extends FieldType>(documentField: ContentStoreTypes.DocumentField, fieldTypes: ReadonlyArray<T>): documentField is ContentStoreTypes.DocumentFieldForType<T> {
+    return fieldTypes.includes(documentField.type as T);
 }
 
-export function getDocumentFieldForLocale<Type extends ContentStoreTypes.FieldType>(
+export function getDocumentFieldForLocale<Type extends FieldType>(
     docField: ContentStoreTypes.DocumentFieldForType<Type>,
     locale?: string
 ): ContentStoreTypes.DocumentFieldNonLocalizedForType<Type> | null {
@@ -31,10 +42,10 @@ export function getDocumentFieldForLocale<Type extends ContentStoreTypes.FieldTy
         if (!localizedField) {
             return null;
         }
-        return ({
+        return {
             ...base,
             ...localizedField
-        } as unknown) as ContentStoreTypes.DocumentFieldNonLocalizedForType<Type>;
+        } as unknown as ContentStoreTypes.DocumentFieldNonLocalizedForType<Type>;
     } else {
         return docField;
     }
@@ -194,9 +205,9 @@ export function getCSIDocumentsAndAssetsFromContentSourceDataByIds(
     };
 }
 
-export function updateOperationValueFieldWithCrossReference(type: 'string' | 'text' | 'json', refObject: CrossReferenceData): UpdateOperationValueField {
+export function updateOperationValueFieldWithCrossReference(type: 'string' | 'text' | 'json' | 'cross-reference', refObject: ContentStoreTypes.CrossReferenceData): UpdateOperationValueField {
     return {
         type,
-        value: type === 'json' ? refObject : JSON.stringify(refObject)
+        value: (type === 'json' || type === 'cross-reference') ? refObject : JSON.stringify(refObject)
     };
 }

package/src/content-store.ts

@@ -3,7 +3,7 @@ import path from 'path';
 import sanitizeFilename from 'sanitize-filename';
 
 import * as CSITypes from '@stackbit/types';
-import { getLocalizedFieldForLocale, ModelExtension, UserCommandSpawner } from '@stackbit/types';
+import { getLocalizedFieldForLocale, isOneOfFieldTypes, ModelExtension, UserCommandSpawner } from '@stackbit/types';
 import {
     Config,
     extendModelsWithPresetsIds,
@@ -20,7 +20,7 @@ import {
 } from '@stackbit/sdk';
 import { append, deferWhileRunning, mapPromise, reducePromise } from '@stackbit/utils';
 
-import * as ContentStoreTypes from './content-store-types';
+import * as ContentStoreTypes from './types';
 import { Timer } from './utils/timer';
 import { SearchFilter } from './types/search-filter';
 import { searchDocuments } from './utils/search-utils';
@@ -48,15 +48,20 @@ import { mergeObjectWithDocument } from './utils/duplicate-document';
 import { normalizeModels, validateModels } from './utils/model-utils';
 import { IMAGE_MODEL } from './common/common-schema';
 import { getDocumentObjectFromPreset, getPresetFromDocument } from './utils/preset-utils';
+import { GitService } from './services';
+import { CommandRunner } from '@stackbit/types';
 
 export type HandleConfigAssets = <T extends Model>({ models, presets }: { models?: T[]; presets?: PresetMap }) => Promise<{ models: T[]; presets: PresetMap }>;
 
 export interface ContentSourceOptions {
-    logger: ContentStoreTypes.Logger;
-    userLogger: ContentStoreTypes.Logger;
+    logger: CSITypes.Logger;
+    userLogger: CSITypes.Logger;
     localDev: boolean;
+    staticAssetsPublicPath: string;
     webhookUrl?: string;
-    userCommandSpawner?: UserCommandSpawner;
+    runCommand: CommandRunner;
+    git: GitService;
+    userCommandSpawner?: UserCommandSpawner; //TODO remove
     onSchemaChangeCallback: () => void;
     onContentChangeCallback: (contentChanges: ContentStoreTypes.ContentChangeResult) => void;
     handleConfigAssets: HandleConfigAssets;
@@ -69,11 +74,14 @@ type ContentSourceRawData = Omit<ContentSourceData, 'models' | 'modelMap' | 'doc
 export const StackbitPresetModelName = 'stackbitPreset';
 
 export class ContentStore {
-    private readonly logger: ContentStoreTypes.Logger;
-    private readonly userLogger: ContentStoreTypes.Logger;
+    private readonly logger: CSITypes.Logger;
+    private readonly userLogger: CSITypes.Logger;
     private readonly userCommandSpawner?: UserCommandSpawner;
     private readonly localDev: boolean;
+    private readonly staticAssetsPublicPath: string;
     private readonly webhookUrl?: string;
+    private readonly runCommand: CommandRunner;
+    private readonly git: GitService;
     private readonly onSchemaChangeCallback: () => void;
     private readonly onContentChangeCallback: (contentChanges: ContentStoreTypes.ContentChangeResult) => void;
     private readonly handleConfigAssets: HandleConfigAssets;
@@ -93,7 +101,10 @@ export class ContentStore {
         this.logger = options.logger.createLogger({ label: 'content-store' });
         this.userLogger = options.userLogger.createLogger({ label: 'content-store' });
         this.localDev = options.localDev;
+        this.staticAssetsPublicPath = options.staticAssetsPublicPath;
         this.webhookUrl = options.webhookUrl;
+        this.runCommand = options.runCommand;
+        this.git = options.git;
         this.userCommandSpawner = options.userCommandSpawner;
         this.onSchemaChangeCallback = options.onSchemaChangeCallback;
         this.onContentChangeCallback = options.onContentChangeCallback;
@@ -430,7 +441,9 @@ export class ContentStore {
                 userCommandSpawner: this.userCommandSpawner,
                 localDev: this.localDev,
                 webhookUrl: this.getWebhookUrl(contentSourceInstance.getContentSourceType(), contentSourceInstance.getProjectId()),
-                devAppRestartNeeded: this.devAppRestartNeeded
+                devAppRestartNeeded: this.devAppRestartNeeded,
+                runCommand: this.runCommand,
+                git: this.git
             });
         } else {
             contentSourceInstance.stopWatchingContentUpdates();
@@ -481,7 +494,7 @@ export class ContentStore {
                 }
                 this.logger.debug('content source called onContentChange.', { contentSourceId });
                 const result = this.onContentChange(contentSourceId, contentChangeEvent);
-                
+
                 this.siteMapEntryGroups = await updateSiteMapEntriesWithContentChanges({
                     siteMapEntryGroups: this.siteMapEntryGroups,
                     contentChanges: result,
@@ -1116,7 +1129,7 @@ export class ContentStore {
         return _.reduce(
             this.contentSourceDataById,
             (objects: ContentStoreTypes.APIObject[], contentSourceData) => {
-                let documents = objectIds 
+                let documents = objectIds
                     ? contentSourceData.documents.filter((document) => objectIds.includes(document.srcObjectId))
                     : contentSourceData.documents;
                 documents = hasExplicitLocale
@@ -1154,12 +1167,12 @@ export class ContentStore {
         if (srcProjectId && srcType) {
             const contentSourceId = getContentSourceId(srcType, srcProjectId);
             const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-            assets = mapStoreAssetsToAPIAssets(contentSourceData.assets, contentSourceData.defaultLocaleCode);
+            assets = mapStoreAssetsToAPIAssets(contentSourceData.assets, this.staticAssetsPublicPath, contentSourceData.defaultLocaleCode);
         } else {
             assets = _.reduce(
                 this.contentSourceDataById,
                 (result: ContentStoreTypes.APIAsset[], contentSourceData) => {
-                    const assets = mapStoreAssetsToAPIAssets(contentSourceData.assets, contentSourceData.defaultLocaleCode);
+                    const assets = mapStoreAssetsToAPIAssets(contentSourceData.assets, this.staticAssetsPublicPath, contentSourceData.defaultLocaleCode);
                     return result.concat(assets);
                 },
                 []
@@ -1283,10 +1296,10 @@ export class ContentStore {
                 refId: result.srcDocumentId
             } as CSITypes.UpdateOperationReferenceField;
         } else {
-            if (!['string', 'text', 'json'].includes(csiFieldProps.type)) {
+            if (!isOneOfFieldTypes(csiFieldProps.type, ['string', 'text', 'json', 'cross-reference'])) {
                 throw new Error(`The 'cross-reference' field can be only applied on string, text and json fields: ${fieldPath.join('.')}`);
             }
-            field = updateOperationValueFieldWithCrossReference(csiFieldProps.type as 'string' | 'text' | 'json', {
+            field = updateOperationValueFieldWithCrossReference(csiFieldProps.type, {
                 refId: result.srcDocumentId,
                 refSrcType: refSrcType,
                 refProjectId: refProjectId
@@ -1733,7 +1746,7 @@ export class ContentStore {
             contentSourceInstance: contentSourceData.instance,
             defaultLocaleCode: contentSourceData.defaultLocaleCode
         });
-        return mapStoreAssetsToAPIAssets(storeAssets, locale);
+        return mapStoreAssetsToAPIAssets(storeAssets, this.staticAssetsPublicPath, locale);
     }
 
     async deleteDocument({

package/src/index.ts

@@ -6,7 +6,8 @@ export * as consts from './consts';
 export * from './common/common-schema';
 export * from './common/common-types';
 export * from './content-store';
-export * as ContentStoreTypes from './content-store-types';
+export * as ContentStoreTypes from './types';
 export { default as encodeData } from './encoder';
 export * from './encoder';
 export * from './types/search-filter';
+export * from './services';

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
+            });
+        });
+    });
+}