@stackbit/cms-core 1.0.13-develop.1 → 1.0.13-develop.2

package/src/connector/model-converter.mts

@@ -0,0 +1,162 @@
+import * as CSITypes from '@stackbit/types';
+
+export function convertModels(models: Map<string, any>) {
+    const createModels: (CSITypes.DataModel | CSITypes.ObjectModel)[] = [];
+    models.forEach((model: any) => {
+        if (model.getTypeName() === `Image`) {
+            return;
+        }
+        const createModel = convertModel(model, models);
+        if (createModel) {
+            createModels.push(createModel);
+        }
+    });
+    return createModels;
+}
+
+function convertModel(model: any, models: any) {
+    let fieldGroups = model.fieldGroups;
+
+    if (model.devOnlyFieldGroup) {
+        fieldGroups ||= [];
+        fieldGroups.push(model.devOnlyFieldGroup);
+    }
+
+    // Create doesn't have named union types
+    if (model.isUnionType) { 
+        return false;
+    }
+    const name = model.originalName || model.typeName;
+    const csiModel = {
+        name: name,
+        label: model.label || model.name,
+        type: model.isObjectType ? (`object` as const) : (`data` as const),
+        fieldGroups,
+        fields: sdkFieldsToStackbitFields(model.fields, models)
+    };
+
+    return csiModel;
+}
+
+function sdkFieldsToStackbitFields(fields: any[], models: any) {
+    return fields.map((field): CSITypes.Field | CSITypes.FieldList => {
+        const definedTypename = field.type;
+        const fieldModel = models.get(definedTypename);
+        const typename = fieldModel?.originalName || definedTypename;
+
+        const isObject = fieldModel?.isObjectType;
+
+        const scalarTypename = isObject
+            ? `object`
+            : ({
+                  // create only has a number field
+                  float: 'number',
+                  int: 'number'
+              } as Record<string, CSITypes.Field['type'] | undefined>)[typename.toLowerCase()] ||
+              // all other scalar types are supported as lowercase typenames
+              (typename.toLowerCase() as CSITypes.Field['type']);
+
+        const isImage = typename === `Image`;
+        const isReference = !isImage && fieldModel?.isNodeType;
+        const isUnion = fieldModel?.isUnionType;
+        const firstUnionType = isUnion && fieldModel?.compositeTypes && models.get(fieldModel.compositeTypes[0]);
+
+        const isObjectUnion = firstUnionType && firstUnionType.isObjectType;
+        const isReferenceUnion = firstUnionType && firstUnionType.isNodeType;
+
+        const type: CSITypes.FieldType = (() => {
+            if (/*isObject || */isObjectUnion) {
+                return `model`;
+            }
+            if (isReference || isReferenceUnion) {
+                return `reference`;
+            }
+            if (isUnion) {
+                // throw new ModelError(`Unhandled union type for model ${typename}. This is a bug in the Netlify SDK.`);
+            }
+
+            if (isImage) {
+                return `image`;
+            }
+            return scalarTypename;
+        })();
+
+        const stackbitField: Partial<CSITypes.Field> = {
+            type,
+            name: field.name
+        };
+
+        if (typename.toLowerCase() === `float`) {
+            (stackbitField as CSITypes.FieldNumberProps).subtype = `float`;
+        }
+
+        //TODO
+        if (isObject) {
+            (stackbitField as CSITypes.FieldObject).fields = fieldModel.sdkFieldsToStackbitFields();
+        }
+
+        // if (isObject) {
+        //     (stackbitField as CSITypes.FieldModelProps).models = [typename];
+        // }
+
+        // if (isObjectUnion) {
+        //     (stackbitField as CSITypes.FieldModelProps).models = fieldModel.compositeTypes.map((ct: any) => {
+        //         const fullType = models.get(ct);
+        //         return fullType!.getOriginalName();
+        //     });
+        // }
+
+        // any field names starting with _ are internal mandatory fields.
+        // they shouldn't be set as required in the Create UI as content admins
+        // don't need to set these fields, connector authors do.
+        if (`required` in field && !field.name.startsWith(`_`)) {
+            stackbitField.required = field.required;
+        }
+
+        if (`label` in field) {
+            stackbitField.label = field.label;
+        }
+
+        if (`hidden` in field) {
+            stackbitField.hidden = field.hidden;
+        }
+
+        if (`readOnly` in field) {
+            stackbitField.readOnly = field.readOnly;
+        }
+
+        if (`localized` in field) {
+            stackbitField.localized = field.localized;
+        }
+
+        if (`defaultValue` in field) {
+            stackbitField.default = field.defaultValue;
+        }
+
+        if (`group` in field) {
+            stackbitField.group = field.group;
+        }
+
+        if (isUnion) {
+            (stackbitField as CSITypes.FieldReferenceProps).models = (fieldModel.compositeTypes || []).map((ct: any) => {
+                const fullType = models.get(ct);
+                return fullType!.getOriginalName();
+            });
+        } else if (isReference) {
+            (stackbitField as CSITypes.FieldReferenceProps).models = [fieldModel.getOriginalName()];
+        }
+
+        if (field.list) {
+            const { name, required, hidden, ...items } = stackbitField;
+            return {
+                name,
+                required,
+                hidden,
+                type: `list`,
+                items
+            } as CSITypes.FieldList;
+        } else {
+            return stackbitField as CSITypes.Field;
+        }
+    });
+}

package/src/consts.js

@@ -0,0 +1,31 @@
+const { RICH_TEXT_NODE_TYPES, RICH_TEXT_MARK_TYPES, RICH_TEXT_HINT_MAX_LENGTH } = require('@stackbit/types');
+
+const SIMPLE_VALUE_FIELDS = ['string', 'text', 'markdown', 'number', 'url', 'slug', 'boolean', 'date', 'datetime', 'color'];
+
+const LOADER_EXCLUDED_FILES = [
+    'LICENSE.md',
+    'README.md',
+    'README.theme.md',
+    'CONTRIBUTING.md',
+    'CHANGELOG.md',
+    'stackbit.yaml',
+    'netlify.toml',
+    'theme.toml',
+    'package.json',
+    'package-lock.json',
+    'yarn-lock.json'
+];
+
+const LOADER_EXCLUDED_DIRS = ['src/pages'];
+
+const STACKBIT_PRESET_MODEL_NAME = 'stackbitPreset';
+
+module.exports = {
+    RICH_TEXT_NODE_TYPES,
+    RICH_TEXT_MARK_TYPES,
+    RICH_TEXT_HINT_MAX_LENGTH,
+    SIMPLE_VALUE_FIELDS,
+    LOADER_EXCLUDED_FILES,
+    LOADER_EXCLUDED_DIRS,
+    STACKBIT_PRESET_MODEL_NAME
+};

package/src/content-store.ts

@@ -278,9 +278,6 @@ export class ContentStore {
 
     async destroy() {
         this.contentUpdatesWatchTimer.stopTimer();
-        this.contentEngine?.clearListeners();
-        await this.contentEngine?.stop();
-        this.contentEngine = null;
         for (const contentSourceInstance of this.contentSources) {
             contentSourceInstance.stopWatchingContentUpdates?.();
             await contentSourceInstance.destroy?.();
@@ -414,34 +411,31 @@ export class ContentStore {
      */
     private async createContentEngineIfNeeded() {
         const logger = this.userLogger.createLogger({ label: 'content-engine' });
+
         if (this.contentEngine) {
-            logger.info('stopping content engine');
-            this.contentEngine.clearListeners();
-            await this.contentEngine.stop();
-            this.contentEngine = null;
+            logger.debug(
+                `Content Engine already exists, cannot recreate it as it's running in this process. To recreate it with updated config options the current process must be restarted.`
+            );
+            return;
         }
+
+        const contentSources = this.contentSources || [];
         const plugins = Array.from(
-            new Set(this.contentSources?.flatMap((contentSource) => contentSource.getContentEngineConfig?.()?.plugins).filter(Boolean))
+            new Set(contentSources.flatMap((contentSource) => contentSource.getContentEngineConfig?.()?.plugins).filter(Boolean))
         ) as PluginRef[];
         if (plugins.length < 1) {
             return;
         }
-        logger.info('creating content engine');
+        logger.info('Creating content engine');
         this.contentEngine = contentEngine({
             directory: this.stackbitConfig?.dirPath,
             port: this.stackbitConfig?.contentEngine?.port,
             host: this.stackbitConfig?.contentEngine?.host,
             engineConfig: {
                 plugins
-            }
-        });
-
-        this.contentEngine?.onStdOut((data) => {
-            logger.info(data.toString());
-        });
-
-        this.contentEngine?.onStdErr((data) => {
-            logger.error(data.toString());
+            },
+            // content engine must run in the same process so that unified connectors can share state in memory
+            runInSubProcess: false
         });
     }
 
@@ -491,12 +485,29 @@ export class ContentStore {
 
         if (init) {
             this.logger.debug('init content sources');
+            if (this.stackbitConfig?.connectors) {
+                const contentSources = this.contentSources || [];
+                if (this.stackbitConfig?.connectors?.length) {
+                    const ConnectorWrapper = (await import('./connector/connector-wrapper.mjs')).default;
+                    for (const connector of this.stackbitConfig.connectors) {
+                        contentSources.push(new ConnectorWrapper(connector));
+                    }
+                }
+                this.contentSources = contentSources;
+            }
             await this.createContentEngineIfNeeded();
-            await this.contentEngine?.sync({
-                runServer: true
-            });
         }
 
+        const contentEngineSyncPromise = this.contentEngine
+            ? // store the content engine sync promise instead of awaiting here
+              // unified connectors need the internal CSI + source plugin to run simultaneously.
+              // waiting for this promise here means internal unified connector APIs will be stuck forever
+              // it's awaited further below
+              this.contentEngine?.sync({
+                  runServer: true
+              })
+            : Promise.resolve();
+
         const promises = contentSources.map((contentSourceInstance): Promise<ContentSourceRawData> => {
             const contentSourceId = getContentSourceIdForContentSource(contentSourceInstance);
             if (init || !contentSourceIds || contentSourceIds.includes(contentSourceId)) {
@@ -561,6 +572,8 @@ export class ContentStore {
         const processingPromise = this.processingContentSourcesPromise;
         this.processingContentSourcesPromise = null;
 
+        await contentEngineSyncPromise;
+
         // Do not "await" on processContentStoreEvents as it may introduce a deadlock with
         // the nested loadContentSourcesAndProcessData call which is wrapped by deferWhileRunning.
         this.processContentStoreEvents()
@@ -819,14 +832,6 @@ export class ContentStore {
                 }
                 this.logger.debug('content source called updateContent', { contentSourceId });
 
-                if (contentEngineConfig && this.contentEngine) {
-                    this.logger.debug(`syncing ${contentEngineConfig.connector}`);
-                    await this.contentEngine.sync({
-                        buildSchema: false,
-                        connector: contentEngineConfig.connector
-                    });
-                }
-
                 this.pushContentSourceEvent({
                     eventName: ContentStoreEventType.ContentSourceContentChange,
                     contentSourceId: contentSourceId,
@@ -3179,10 +3184,23 @@ export class ContentStore {
         return getContentSourceDataByIdOrThrow(contentSourceId, this.contentSourceDataById);
     }
 
-    onWebhook({ srcType, srcProjectId, data, headers }: { srcType: string; srcProjectId: string; data: unknown; headers: Record<string, string> }) {
-        const contentSourceId = getContentSourceId(srcType, srcProjectId);
-        const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
-        return contentSourceData.instance.onWebhook?.({ data, headers });
+    async onWebhook({ srcType, srcProjectId, data, headers }: { srcType: string; srcProjectId: string; data: unknown; headers: Record<string, string> }) {
+        if (this.contentEngine) {
+            // if there's a content-engine always pass the webhook body to it
+            await this.contentEngine.sync({
+                webhookBody: data as any,
+                // selective connector syncing can happen via a header
+                connector: headers?.connector
+            });
+        }
+
+        // unified connectors handle their own webhook syncing via the .sync call above.
+        // passing "connector" as the source type in the webhook url opts out of traditional CSI onWebhook calls
+        if (srcType !== `connector`) {
+            const contentSourceId = getContentSourceId(srcType, srcProjectId);
+            const contentSourceData = this.getContentSourceDataByIdOrThrow(contentSourceId);
+            return contentSourceData.instance.onWebhook?.({ data, headers });
+        }
     }
 
     getWebhookUrl(contentSourceType: string, projectId: string) {

package/src/consts.ts

@@ -1,21 +0,0 @@
-export { RICH_TEXT_NODE_TYPES, RICH_TEXT_MARK_TYPES, RICH_TEXT_HINT_MAX_LENGTH } from '@stackbit/types';
-
-export const SIMPLE_VALUE_FIELDS = ['string', 'text', 'markdown', 'number', 'url', 'slug', 'boolean', 'date', 'datetime', 'color'];
-
-export const LOADER_EXCLUDED_FILES = [
-    'LICENSE.md',
-    'README.md',
-    'README.theme.md',
-    'CONTRIBUTING.md',
-    'CHANGELOG.md',
-    'stackbit.yaml',
-    'netlify.toml',
-    'theme.toml',
-    'package.json',
-    'package-lock.json',
-    'yarn-lock.json'
-];
-
-export const LOADER_EXCLUDED_DIRS = ['src/pages'];
-
-export const STACKBIT_PRESET_MODEL_NAME = 'stackbitPreset';