@stackbit/sdk 0.2.33 → 0.2.36-alpha.0

package/src/config/presets-loader.ts

@@ -3,7 +3,7 @@ import path from 'path';
 import fse from 'fs-extra';
 import { parseFile, append } from '@stackbit/utils';
 
-import { Config } from './config-types';
+import { Config, Preset } from './config-types';
 import { ConfigPresetsError } from './config-errors';
 
 export interface PresetsLoaderResult {
@@ -11,6 +11,17 @@ export interface PresetsLoaderResult {
     errors: ConfigPresetsError[];
 }
 
+interface RawPresetData {
+    model: string;
+    presets: RawPreset[];
+}
+
+interface RawPreset {
+    label: string;
+    thumbnail?: string;
+    data: Record<string, any>;
+}
+
 export async function loadPresets(dirPath: string, config: Config): Promise<PresetsLoaderResult> {
     const presetFiles = [];
     const presetsRelDirs = ['.stackbit/presets', 'node_modules/@stackbit/components/presets'];
@@ -26,14 +37,14 @@ export async function loadPresets(dirPath: string, config: Config): Promise<Pres
         presetFiles.push(...files);
     }
 
-    const presets: Record<string, any> = {};
-    const presetsIdsByModel: Record<string, any> = {};
+    const presets: Record<string, Preset> = {};
+    const presetsIdsByModel: Record<string, string[]> = {};
     const errors: ConfigPresetsError[] = [];
 
     for (const presetFile of presetFiles) {
         const presetsRelDir = path.dirname(presetFile);
         const presetPath = path.join(dirPath, presetFile);
-        let presetData: any;
+        let presetData: RawPresetData;
         try {
             presetData = await parseFile(presetPath);
         } catch (err: any) {
@@ -42,11 +53,12 @@ export async function loadPresets(dirPath: string, config: Config): Promise<Pres
         }
         _.forEach(_.get(presetData, 'presets', []), (preset, i) => {
             const presetId = `${presetFile}:presets[${i}]`;
-            presets[presetId] = preset;
-            if (preset.thumbnail) {
-                preset.thumbnail = resolveThumbnailPath(preset.thumbnail, presetsRelDir);
-            }
-            _.set(preset, 'modelName', presetData.model);
+            const { thumbnail, ...rest } = preset;
+            presets[presetId] = {
+                ...rest,
+                ...(thumbnail ? { thumbnail: resolveThumbnailPath(thumbnail, presetsRelDir) } : null),
+                modelName: presetData.model
+            };
             append(presetsIdsByModel, presetData.model, presetId);
         });
     }

package/src/index.ts

@@ -5,7 +5,7 @@ export * from './content/content-errors';
 export * from './config/config-errors';
 export * from './analyzer/file-browser';
 export * from './utils';
-export { loadConfig, ConfigLoaderOptions, ConfigLoaderResult } from './config/config-loader';
+export { loadConfig, loadConfigFromDir, extendConfig, ConfigLoaderOptions, ConfigLoaderResult } from './config/config-loader';
 export { writeConfig, WriteConfigOptions, convertToYamlConfig } from './config/config-writer';
 export { loadContent, ContentItem, ContentLoaderOptions, ContentLoaderResult } from './content/content-loader';
 export { matchSSG, SSGMatcherOptions, SSGMatchResult } from './analyzer/ssg-matcher';

package/src/utils/index.ts

@@ -9,7 +9,7 @@ type StricterUnionMember<T, Union, Keys extends string = UnionKeys<Union> extend
 
 export type StricterUnion<Union, Union2 = Union> = Union2 extends any ? StricterUnionMember<Union2, Union> : never;
 
-export type Logger = Pick<Console, 'log' | 'info' | 'warn' | 'error' | 'group' | 'groupEnd'>;
+export type Logger = Pick<Console, 'log' | 'debug' | 'info' | 'warn' | 'error' | 'group' | 'groupEnd'>;
 
 export * from './model-utils';
 export * from './model-matcher';

package/src/utils/model-iterators.ts

@@ -1,5 +1,6 @@
 import _ from 'lodash';
 
+import { mapPromise, mapValuesPromise } from '@stackbit/utils';
 import { getListFieldItems, isListDataModel, isListField, isObjectListItems, isModelField, isObjectField, isModelListItems } from './model-utils';
 import { DataModel, Field, FieldList, FieldListItems, FieldModelProps, FieldObjectProps, Model } from '../config/config-types';
 
@@ -366,6 +367,150 @@ export function mapObjectFieldsWithModelRecursively(
     });
 }
 
+export async function asyncMapObjectFieldsWithModelRecursively({
+    value,
+    model,
+    modelsByName,
+    iteratee,
+    pageLayoutKey = 'layout',
+    objectTypeKey = 'type',
+    valueId
+}: {
+    value: any;
+    model: Model;
+    modelsByName: Record<string, Model>;
+    iteratee: (options: {
+        value: any;
+        model: Model | null;
+        field: Field | null;
+        fieldListItem: FieldListItems | null;
+        error: string | null;
+        valueKeyPath: (string | number)[];
+        modelKeyPath: string[];
+        objectStack: any[];
+        skipNested: () => void;
+    }) => Promise<any>;
+    pageLayoutKey?: string;
+    objectTypeKey?: string;
+    valueId?: string;
+}): Promise<any> {
+    async function _mapDeep({
+        value,
+        model,
+        field,
+        fieldListItem,
+        valueKeyPath,
+        modelKeyPath,
+        objectStack
+    }: {
+        value: any;
+        model: Model | null;
+        field: Field | null;
+        fieldListItem: FieldListItems | null;
+        valueKeyPath: (string | number)[];
+        modelKeyPath: string[];
+        objectStack: any[];
+    }) {
+        let error: string | null = null;
+        let modelField: FieldModelProps | null = null;
+
+        if (!model && !field && !fieldListItem) {
+            error = `could not match model/field ${modelKeyPath.join('.')} to content at ${valueKeyPath.join('.')}`;
+        }
+
+        if (field && isModelField(field)) {
+            modelField = field;
+        } else if (fieldListItem && isModelListItems(fieldListItem)) {
+            modelField = fieldListItem;
+        }
+
+        if (modelField) {
+            const modelResult = getModelOfObject({
+                object: value,
+                field: modelField,
+                modelsByName,
+                pageLayoutKey,
+                objectTypeKey,
+                valueKeyPath,
+                modelKeyPath
+            });
+            if ('error' in modelResult) {
+                error = modelResult.error;
+            } else {
+                model = modelResult.model;
+            }
+            field = null;
+            fieldListItem = null;
+            modelKeyPath = model ? [model.name] : [];
+        }
+
+        let shouldSkipNested = false;
+        const skipNested = () => {
+            shouldSkipNested = true;
+        };
+
+        const res = await iteratee({ value, model, field, fieldListItem, error, valueKeyPath, modelKeyPath, objectStack, skipNested });
+        if (!_.isUndefined(res)) {
+            value = res;
+        }
+
+        if (shouldSkipNested) {
+            return value;
+        }
+
+        if (_.isPlainObject(value)) {
+            // if fields will not be resolved or the object will have a key that
+            // doesn't exist among fields, the nested calls to _iterateDeep will
+            // include an error.
+            const fields = getFieldsOfModelOrField(model, field, fieldListItem);
+            const fieldsByName = _.keyBy(fields, 'name');
+            modelKeyPath = _.concat(modelKeyPath, 'fields');
+            value = await mapValuesPromise(value, (val, key) => {
+                const field = _.get(fieldsByName, key, null);
+                return _mapDeep({
+                    value: val,
+                    model: null,
+                    field: field,
+                    fieldListItem: null,
+                    valueKeyPath: _.concat(valueKeyPath, key),
+                    modelKeyPath: _.concat(modelKeyPath, key),
+                    objectStack: _.concat(objectStack, value)
+                });
+            });
+        } else if (_.isArray(value)) {
+            let fieldListItems: FieldListItems | null = null;
+            if (field && isListField(field)) {
+                fieldListItems = getListFieldItems(field);
+            } else if (model && isListDataModel(model)) {
+                fieldListItems = model.items;
+            }
+            value = await mapPromise(value, (val, idx) => {
+                return _mapDeep({
+                    value: val,
+                    model: null,
+                    field: null,
+                    fieldListItem: fieldListItems,
+                    valueKeyPath: _.concat(valueKeyPath, idx),
+                    modelKeyPath: _.concat(modelKeyPath, 'items'),
+                    objectStack: _.concat(objectStack, value)
+                });
+            });
+        }
+
+        return value;
+    }
+
+    return _mapDeep({
+        value: value,
+        model: model,
+        field: null,
+        fieldListItem: null,
+        valueKeyPath: valueId ? [valueId] : [],
+        modelKeyPath: [model.name],
+        objectStack: []
+    });
+}
+
 export function getModelOfObject({
     object,
     field,