@stackbit/dev 0.0.54 → 0.0.56-alpha.1

package/src/runner/index.ts

@@ -1,23 +1,34 @@
 import _ from 'lodash';
 import path from 'path';
-import ssg from './ssg';
-import Editor from '@stackbit/dev-common/dist/runner/editor';
-import GitCMS from '@stackbit/dev-common/dist/cms/git/git';
-import { Contentful as ContentfulCMS } from '@stackbit/dev-common/dist/cms/contentful/contentful';
-import SanityCMS from '@stackbit/dev-common/dist/cms/sanity/sanity';
-import Worker from '@stackbit/dev-common/dist/utils/worker';
-import { StackbitYaml } from '@stackbit/dev-common/dist/services/stackbit-yaml';
-import socketService from '@stackbit/dev-common/dist/services/socket-service';
+
+import { Editor, StackbitYaml, ContentStoreAdapter, Worker } from '@stackbit/dev-common';
+import { ContentStoreTypes } from '@stackbit/cms-core';
 
 import { watchDir } from '../services/file-watcher';
 import logger from '../services/logger';
 import consts from '../consts';
+import ssg from './ssg';
 import { logAnnotationErrors } from '../services/annotation-errors';
+import {
+    APIMethodCreateDocument,
+    APIMethodCreatePreset,
+    APIMethodDeleteDocument,
+    APIMethodDeletePreset,
+    APIMethodDuplicateDocument,
+    APIMethodGetAssets,
+    APIMethodUpdateDocument,
+    APIMethodUploadAssets,
+    APIMethodValidateDocuments,
+    APIMethodPublishDocuments,
+    APIMethodCreateAndLinkDocument,
+    APIMethodUploadAndLinkAsset
+} from '../types/api-methods';
 
 interface RunnerOptions {
     rootDir: string;
     runnableDir?: string;
     cmsType?: string;
+    csiEnabled?: boolean;
     contentfulAccessToken?: string;
     contentfulSpaceIds?: [string];
     contentfulPreviewTokens?: [string];
@@ -28,131 +39,90 @@ interface RunnerOptions {
     sanityStudioUrl?: string;
 }
 export default class Runner {
-    private editor: any;
-    private cmsType?: string;
-    private cms: any;
-    private stackbitYaml: any;
-    private workers: any;
+    private readonly stackbitYaml: StackbitYaml;
+    private readonly contentStoreAdapter: ContentStoreAdapter;
+    private readonly editor: Editor;
+    private readonly workers: { gitApp: Worker };
+    private readonly rootDir: string;
+    private readonly appDir: string;
     private watcher: any;
     private ssg: any;
 
-    private readonly options: RunnerOptions;
-    private rootDir: string;
-    private appDir?: string;
-
     constructor(options: RunnerOptions) {
-        this.options = options;
         this.rootDir = options.rootDir;
         this.appDir = options.runnableDir ? path.join(this.rootDir, options.runnableDir) : this.rootDir;
-        this.cmsType = options.cmsType;
 
         this.workers = {
             gitApp: new Worker()
         };
-    }
 
-    async install() {
         this.stackbitYaml = new StackbitYaml({
             repoDir: this.rootDir,
             appDir: this.appDir,
-            logger,
+            logger: logger,
             userLogger: logger,
             envName: 'local' //TODO
         });
-        await this.stackbitYaml.load();
-        this.cms = this.createCms();
-        await this.cms.run();
-        this.editor = new Editor(null, this.cms, this.stackbitYaml, {
-            logger,
+
+        this.contentStoreAdapter = new ContentStoreAdapter({
+            cmsType: options.cmsType!,
+            csiEnabled: options.csiEnabled,
+            stackbitYaml: this.stackbitYaml,
+            workers: this.workers,
+            rootDir: this.rootDir,
+            projectDir: this.rootDir,
+            appDir: this.appDir,
+            logger: logger,
+            userLogger: logger,
+            localDev: true,
+            contentfulAccessToken: options.contentfulAccessToken,
+            contentfulSpaces: options.contentfulSpaceIds?.map((spaceId, i) => ({
+                spaceId,
+                previewToken: options.contentfulPreviewTokens?.[i]!
+            })),
+            sanityProject: {
+                projectId: options.sanityProjectId!,
+                token: options.sanityToken!,
+                studioPath: options.sanityStudioPath!,
+                dataset: options.sanityDataset!,
+                projectUrl: options.sanityStudioUrl!
+            },
+            assetIdPrefix: consts.ASSET_ID_PREFIX,
+            staticAssetsFilePath: consts.STATIC_ASSETS_FILE_PATH,
+            staticAssetsPublicPath: consts.STATIC_ASSETS_PUBLIC_PATH,
+            staticThemeAssetsFilePath: consts.STATIC_THEME_ASSETS_FILE_PATH,
+            staticThemeAssetsPublicPath: consts.STATIC_THEME_ASSETS_PUBLIC_PATH,
+            defaultContentTypeExtensions: consts.DEFAULT_CONTENT_TYPE_EXTENSIONS
+        });
+
+        this.editor = new Editor({
+            contentStoreAdapter: this.contentStoreAdapter,
+            stackbitYaml: this.stackbitYaml,
+            logger: logger,
             userLogger: logger,
             stackbitUrlPathField: consts.STACKBIT_URL_PATH_FIELD
         });
+    }
+
+    async install() {
+        await this.stackbitYaml.load();
+
+        await this.contentStoreAdapter.init();
+
         this.watcher = watchDir(this.rootDir, (filePaths) => {
             logger.debug(`File change detected: ${filePaths}`);
-            this.handleFileChanges(filePaths).catch((err) => {
-                logger.debug('Handle file change error', { err, filePaths });
-                logger.error('Error handling file changes: ' + filePaths.join(', '));
-            });
+            this.handleFileChanges(filePaths);
         });
         this.ssg = _.assign({}, ssg, this.stackbitYaml.internalStackbitRunnerOptions);
     }
 
-    createCms() {
-        let result;
-        if (this.cmsType === 'contentful') {
-            result = new ContentfulCMS({
-                accessToken: this.options.contentfulAccessToken ?? null,
-                spaces: this.options.contentfulSpaceIds!.map((spaceId, i) => ({
-                    spaceId,
-                    previewToken: this.options.contentfulPreviewTokens![i]
-                })),
-                stackbitYaml: this.stackbitYaml,
-                encodeDelimiter: '',
-                rootDir: this.rootDir,
-                appDir: this.appDir!,
-                repoDir: this.rootDir,
-                staticThemeAssetsFilePath: consts.STATIC_THEME_ASSETS_FILE_PATH,
-                staticThemeAssetsPublicPath: consts.STATIC_THEME_ASSETS_PUBLIC_PATH,
-                watchForContentUpdates: true,
-                onContentUpdate: () => {},
-                logger: logger,
-                userLogger: logger
-            });
-        } else if (this.cmsType === 'sanity') {
-            result = new SanityCMS({
-                rootDir: this.rootDir,
-                repoDir: this.rootDir,
-                appDir: this.appDir,
-                stackbitYaml: this.stackbitYaml,
-                encodeDelimiter: '',
-                workers: this.workers,
-                project: {
-                    projectId: this.options.sanityProjectId,
-                    token: this.options.sanityToken,
-                    studioPath: this.options.sanityStudioPath,
-                    dataset: this.options.sanityDataset,
-                    projectUrl: this.options.sanityStudioUrl
-                },
-                staticAssetsFilePath: consts.STATIC_ASSETS_FILE_PATH,
-                staticAssetsPublicPath: consts.STATIC_ASSETS_PUBLIC_PATH,
-                staticThemeAssetsFilePath: consts.STATIC_THEME_ASSETS_FILE_PATH,
-                staticThemeAssetsPublicPath: consts.STATIC_THEME_ASSETS_PUBLIC_PATH,
-                defaultContentTypeExtensions: consts.DEFAULT_CONTENT_TYPE_EXTENSIONS,
-                onContentUpdate: () => {},
-                logger,
-                userLogger: logger
-            });
-        } else {
-            result = new GitCMS({
-                rootDir: this.rootDir,
-                repoDir: this.rootDir,
-                appDir: this.appDir,
-                stackbitYaml: this.stackbitYaml,
-                workers: this.workers,
-                assetIdPrefix: consts.ASSET_ID_PREFIX,
-                staticAssetsFilePath: consts.STATIC_ASSETS_FILE_PATH,
-                staticAssetsPublicPath: consts.STATIC_ASSETS_PUBLIC_PATH,
-                staticThemeAssetsFilePath: consts.STATIC_THEME_ASSETS_FILE_PATH,
-                staticThemeAssetsPublicPath: consts.STATIC_THEME_ASSETS_PUBLIC_PATH,
-                defaultContentTypeExtensions: consts.DEFAULT_CONTENT_TYPE_EXTENSIONS,
-                logger,
-                userLogger: logger
-            });
-        }
-        return result;
-    }
-
-    async handleFileChanges(filePaths: string[]) {
-        const pullResult = await this.cms.postPull(filePaths.map((filePath) => path.join(this.rootDir, filePath))).catch((err: any) => {
-            logger.debug('Error in postPull', { err });
-            throw err;
-        });
-        if (pullResult?.schemaChanged) {
-            await this.stackbitYaml.load().catch((err: any) => {
-                logger.debug('Error handling stackbit.yaml change', { err });
-                logger.error('Error reloading stackbit.yaml');
-            });
-            socketService.notifySchemaChange();
+    async handleFileChanges(filePaths: string[]): Promise<void> {
+        try {
+            logger.debug('handleFileChanges', { filePaths });
+            await this.contentStoreAdapter.handleFileChanges(filePaths);
+        } catch (err) {
+            logger.debug('Handle file change error', { err, filePaths });
+            logger.error('Error handling file changes: ' + filePaths.join(', '));
         }
     }
 
@@ -177,7 +147,7 @@ export default class Runner {
         return this.ssg.directChangeSocketOrigin;
     }
 
-    async getObjects({ objectIds = [], locale }: { objectIds: string[]; locale?: string }) {
+    async getObjects({ objectIds = [], locale }: { objectIds: string[]; locale?: string }): Promise<{ objects: ContentStoreTypes.APIObject[] }> {
         return this.editor.getObjects({ objectIds, locale });
     }
 
@@ -203,59 +173,107 @@ export default class Runner {
     }
 
     async getSiteMap() {
-        return this.editor.getSiteMap(this.cms.getEncodingResult());
+        return this.editor.getSiteMap();
     }
 
     async getSchema({ locale }: { locale?: string }) {
         return this.editor.getSchema({ locale });
     }
 
-    async getUrl(objectId: string, projectId: string, locale: string): Promise<any> {
-        return this.editor.getUrl(objectId, projectId, locale);
+    async getUrl(srcDocumentId: string, srcProjectId: string, srcType: string, locale: string): Promise<string | null> {
+        return this.editor.getUrl(srcDocumentId, srcProjectId, srcType, locale);
     }
 
     async getObject(objectId: string, projectId: string): Promise<any> {
-        return this.cms.getObject(objectId, projectId);
+        return this.contentStoreAdapter.getObject_deprecated({ objectId, projectId });
     }
 
     async listAssets(filterParams: any): Promise<any> {
-        return this.cms.listAssets(filterParams);
+        return this.contentStoreAdapter.listAssets_deprecated(filterParams);
     }
 
     async uploadAsset(url: string, filename: string, user: any): Promise<any> {
-        return this.cms.uploadAsset(url, filename, user);
+        return this.contentStoreAdapter.uploadAsset_deprecated({ url, fileName: filename, user });
+    }
+
+    async createDocument(data: APIMethodCreateDocument['data']): Promise<APIMethodCreateDocument['result']> {
+        return this.contentStoreAdapter.createDocument(data);
+    }
+
+    async createAndLinkDocument(data: APIMethodCreateAndLinkDocument['data']): Promise<APIMethodCreateAndLinkDocument['result']> {
+        return this.contentStoreAdapter.createAndLinkDocument(data);
+    }
+
+    async uploadAndLinkAsset(data: APIMethodUploadAndLinkAsset['data']): Promise<APIMethodUploadAndLinkAsset['result']> {
+        return this.contentStoreAdapter.uploadAndLinkAsset(data);
+    }
+
+    async duplicateDocument(data: APIMethodDuplicateDocument['data']): Promise<APIMethodDuplicateDocument['result']> {
+        return this.contentStoreAdapter.duplicateDocument(data);
+    }
+
+    async updateDocument(data: APIMethodUpdateDocument['data']): Promise<APIMethodUpdateDocument['result']> {
+        return this.contentStoreAdapter.updateDocument(data);
+    }
+
+    async deleteDocument(data: APIMethodDeleteDocument['data']): Promise<APIMethodDeleteDocument['result']> {
+        return this.contentStoreAdapter.deleteDocument(data);
+    }
+
+    async validateDocuments(data: APIMethodValidateDocuments['data']): Promise<APIMethodValidateDocuments['result']> {
+        return this.contentStoreAdapter.validateDocuments(data);
+    }
+
+    async publishDocuments(data: APIMethodPublishDocuments['data']): Promise<APIMethodPublishDocuments['result']> {
+        return this.contentStoreAdapter.publishDocuments(data);
+    }
+
+    async getAssets(data: APIMethodGetAssets['data']): Promise<APIMethodGetAssets['result']> {
+        return this.contentStoreAdapter.getApiAssets(data);
+    }
+
+    async uploadAssets(data: APIMethodUploadAssets['data']): Promise<APIMethodUploadAssets['result']> {
+        return this.contentStoreAdapter.uploadAssets(data);
+    }
+
+    async createPreset(data: APIMethodCreatePreset['data']): Promise<APIMethodCreatePreset['result']> {
+        return this.editor.createPreset(this.appDir, data.fieldDataPath, _.omit(data, ['fieldDataPath', 'user', 'dryRun']) as any, data.user, data.dryRun);
+    }
+
+    async deletePreset(data: APIMethodDeletePreset['data']): Promise<APIMethodDeletePreset['result']> {
+        return this.editor.deletePreset(this.appDir, data.presetId, data.user);
     }
 
     async makeAction(action: string, data: any): Promise<any> {
         switch (action) {
             case 'createPage':
-                return this.cms.createObject(data);
+                return this.contentStoreAdapter.createObject_deprecated(data);
             case 'duplicatePage':
-                return this.cms.duplicateObject(data);
+                return this.contentStoreAdapter.duplicateObject_deprecated(data);
             case 'updatePage':
-                return this.cms.updateObject(data.changedFields);
+                return this.contentStoreAdapter.updateObject_deprecated(data);
             case 'deleteObject':
-                return this.cms.deleteObject(data.srcObjectId, data.srcProjectId);
+                return this.contentStoreAdapter.deleteObject_deprecated(data);
             case 'getAssets':
-                const pageId = data.pageId || 1;
-                return this.cms.listAssets(data).then((result: any) => ({
-                    data: result.assets,
-                    meta: {
-                        nextPage: pageId < result.meta.totalPages ? pageId + 1 : null
-                    }
-                }));
+                return this.contentStoreAdapter.getAssets_deprecated(data);
             case 'uploadAssets':
-                return this.cms.uploadAssets(data.assets);
+                return this.contentStoreAdapter.uploadAssets(data);
             case 'createPreset':
-                return this.editor.createPreset(this.appDir, data.fieldDataPath, _.omit(data, ['fieldDataPath', 'user', 'dryRun']), data.user, data.dryRun);
+                return this.editor.createPreset(
+                    this.appDir,
+                    data.fieldDataPath,
+                    _.omit(data, ['fieldDataPath', 'user', 'dryRun']) as any,
+                    data.user,
+                    data.dryRun
+                );
             case 'deletePreset':
                 return this.editor.deletePreset(this.appDir, data.presetId, data.user);
             default:
-                throw new Error('Unsupported Operation: ' + action);
+                throw new Error('Unsupported Operation: ' + data.action);
         }
     }
 
     keepAlive() {
-        _.invoke(this.cms, 'keepAlive');
+        this.contentStoreAdapter.keepAlive();
     }
 }

package/src/server/index.ts

@@ -19,6 +19,7 @@ interface ServerOptions {
     runnableDir?: string;
     uuid: string;
     cmsType?: string;
+    csiEnabled?: boolean;
     contentfulAccessToken?: string;
     contentfulSpaceIds?: [string];
     contentfulPreviewTokens?: [string];
@@ -38,7 +39,7 @@ export async function start({ serverPort, ssgPort, ssgHost, rootDir, runnableDir
     logger.debug('Done runner init');
 
     process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
-    
+
     const server = express();
     const httpServer = http.createServer(server);
     socketService.use(httpServer, logger);

package/src/server/routes.ts

@@ -4,6 +4,7 @@ import bodyParser from 'body-parser';
 import Runner from '../runner';
 import logger from '../services/logger';
 import { PageNotFoundError } from '@stackbit/dev-common/dist/services/response-errors';
+import { APIMethod, APIMethodDataForMethod, APIMethodName, APIMethodResultForMethod } from '../types/api-methods';
 
 const authMiddleware = (uuid: string) => {
     return (req: Request, res: Response, next: NextFunction) => {
@@ -109,9 +110,11 @@ export default function routes(router: Router, runner: Runner, uuid: string) {
             });
     });
     router.get('/_pageUrl', (req: Request, res: Response, next: NextFunction) => {
-        const { entryId: objectId, spaceId: projectId, locale } = req.query;
+        const { srcType, locale } = req.query;
+        const srcProjectId = req.query.srcProjectId ?? req.query.spaceId;
+        const srcDocumentId = req.query.srcDocumentId ?? req.query.entryId;
         runner
-            .getUrl(objectId as string, projectId as string, locale as string)
+            .getUrl(srcDocumentId as string, srcProjectId as string, srcType as string, locale as string)
             .then((url) => res.json({ url }))
             .catch((err) => {
                 if (err !== PageNotFoundError) {
@@ -155,6 +158,7 @@ export default function routes(router: Router, runner: Runner, uuid: string) {
     router.get('/_health', (req: Request, res: Response) => {
         return res.status(200).json({ status: 'ok' });
     });
+
     router.post('/_action', [authMiddleware(uuid), bodyParser.json({ limit: '50mb' })], (req: Request, res: Response, next: NextFunction) => {
         const { action, data } = req.body;
         return runner
@@ -168,8 +172,32 @@ export default function routes(router: Router, runner: Runner, uuid: string) {
                 if (_.has(err, 'stack')) {
                     logger.debug('error.stack: ' + err.stack);
                 }
-                res.status(500).send('Error');
+                res.status(500).json({ error: err.message || err });
                 next(err);
             });
     });
+
+    router.post(
+        '/_stackbit/:method',
+        [authMiddleware(uuid), bodyParser.json({ limit: '50mb' })],
+        <T extends APIMethodName>(req: Request<{ method: T }>, res: Response, next: NextFunction) => {
+            const method: APIMethodName = req.params.method;
+            if (!runner[method]) {
+                logger.error(`method ${method} is not supported`);
+            }
+            const data = req.body;
+            return runner[method](data)
+                .then((result: APIMethod['result']) => {
+                    res.json(result);
+                })
+                .catch((err) => {
+                    logger.error(`error executing ${method} method`, { data, error: err.message || err });
+                    if (_.has(err, 'stack')) {
+                        logger.debug('error.stack: ' + err.stack);
+                    }
+                    res.status(500).send({ error: err.message || err });
+                    next(err);
+                });
+        }
+    );
 }

package/src/services/annotation-errors.ts

@@ -2,7 +2,7 @@ import chalk from 'chalk';
 import _ from 'lodash';
 import path from 'path';
 
-export async function logAnnotationErrors(errors: any[], logger: any, baseDir: string, sourcemaps?: { [k: string]: any }) {
+export function logAnnotationErrors(errors: any[], logger: any, baseDir: string, sourcemaps?: { [k: string]: any }) {
     if (_.isEmpty(errors)) {
         return;
     }

package/src/services/logger.ts

@@ -14,7 +14,7 @@ const logger = winston.createLogger({
     transports: transports
 });
 
-export const createLogger = ({ label }: { label: string }) => {
+export const createLogger = ({ label }: { label: string }): winston.Logger => {
     const formats = defaultFormats.slice();
     if (label) {
         formats.push(
@@ -24,11 +24,21 @@ export const createLogger = ({ label }: { label: string }) => {
             })
         );
     }
-    return winston.createLogger({
+    const logger = winston.createLogger({
         level: config.logLevel,
         format: winston.format.combine(...formats),
         transports: transports
     });
+    logger.createLogger = createLogger;
+    return logger;
 };
 
+declare module "winston" {
+    interface Logger {
+        createLogger: ({ label }: { label: string }) => winston.Logger
+    }
+}
+
+logger.createLogger = createLogger;
+
 export default logger;