@stackbit/sdk 0.3.4 → 0.3.6

package/src/config/presets-loader.ts

@@ -2,15 +2,11 @@ import _ from 'lodash';
 import path from 'path';
 import fse from 'fs-extra';
 import { parseFile, append } from '@stackbit/utils';
+import { ModelWithSource } from '@stackbit/types';
 
-import { Config, Preset } from './config-types';
+import { Config, Model, Preset } from './config-types';
 import { ConfigPresetsError } from './config-errors';
 
-export interface PresetsLoaderResult {
-    config: Config;
-    errors: ConfigPresetsError[];
-}
-
 interface RawPresetData {
     model: string;
     srcType: string;
@@ -24,16 +20,23 @@ interface RawPreset {
     data: Record<string, any>;
 }
 
-export async function loadPresets(dirPath: string, config: Config): Promise<PresetsLoaderResult> {
+export async function loadPresets({
+    config,
+    fallbackSrcType,
+    fallbackSrcProjectId
+}: {
+    config: Config;
+    fallbackSrcType?: string;
+    fallbackSrcProjectId?: string;
+}): Promise<{
+    presets: Record<string, Preset>;
+    errors: ConfigPresetsError[];
+}> {
     const presetFiles = [];
-    let presetsRelDirs = ['.stackbit/presets', 'node_modules/@stackbit/components/presets'];
-
-    if (config.presetSource?.type === 'files' && config.presetSource?.presetDirs) {
-        presetsRelDirs = [...new Set([...presetsRelDirs, ...config.presetSource.presetDirs])];
-    }
+    const presetsRelDirs = getPresetDirs(config);
 
     for (const presetsRelDir of presetsRelDirs) {
-        const presetsDir = path.join(dirPath, presetsRelDir);
+        const presetsDir = path.join(config.dirPath, presetsRelDir);
         if (!(await fse.pathExists(presetsDir))) {
             continue;
         }
@@ -44,12 +47,11 @@ export async function loadPresets(dirPath: string, config: Config): Promise<Pres
     }
 
     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);
+        const presetPath = path.join(config.dirPath, presetFile);
         let presetData: RawPresetData;
         try {
             presetData = await parseFile(presetPath);
@@ -57,6 +59,8 @@ export async function loadPresets(dirPath: string, config: Config): Promise<Pres
             errors.push(new ConfigPresetsError(`Error parsing ${presetFile} (${err?.message})`));
             continue;
         }
+        const srcType = presetData.srcType ?? fallbackSrcType;
+        const srcProjectId = presetData.srcProjectId ?? fallbackSrcProjectId;
         _.forEach(_.get(presetData, 'presets', []), (preset, i) => {
             const presetId = `${presetFile}:presets[${i}]`;
             const { thumbnail, ...rest } = preset;
@@ -64,29 +68,54 @@ export async function loadPresets(dirPath: string, config: Config): Promise<Pres
                 ...rest,
                 ...(thumbnail ? { thumbnail: resolveThumbnailPath(thumbnail, presetsRelDir) } : null),
                 modelName: presetData.model,
-                srcType: presetData.srcType,
-                srcProjectId: presetData.srcProjectId
-            };
-            append(presetsIdsByModel, presetData.model, presetId);
+                ...(srcType ? { srcType } : null),
+                ...(srcProjectId ? { srcProjectId } : null),
+            } as Preset;
         });
     }
 
+    return {
+        presets,
+        errors
+    };
+}
+
+export function getPresetDirs(config: Config): string[] {
+    const defaultPresetsDirs = ['.stackbit/presets', 'node_modules/@stackbit/components/presets'];
+    if (config.presetSource?.type === 'files' && config.presetSource?.presetDirs) {
+        return [...new Set([...defaultPresetsDirs, ...config.presetSource.presetDirs])];
+    }
+    return defaultPresetsDirs;
+}
+
+export function extendModelsWithPresetsIds<T extends Model | ModelWithSource>({ models, presets }: { models: T[]; presets: Record<string, Preset> }): T[] {
+    // for older projects that pass the Model, we assume that all presets belong to the same content-source
+    const presetsIdsByContentSourceAndModel: Record<string, Record<string, Record<string, string[]>>> = {};
+    const presetsIdsByModel_deprecated: Record<string, string[]> = {};
+    for (const [presetId, preset] of Object.entries(presets)) {
+        append(presetsIdsByContentSourceAndModel, [preset.srcType, preset.srcProjectId, preset.modelName], presetId);
+        append(presetsIdsByModel_deprecated, preset.modelName, presetId);
+    }
+
     // update models with presets IDs
-    const models = _.map(config.models, (model) => {
-        const presetIdsForModel = presetsIdsByModel[model.name];
+    return models.map((model) => {
+        let presetIdsForModel: string[] | undefined;
+        if ('srcType' in model && 'srcProjectId' in model) {
+            // "as" can be removed in typescript 4.3.5 and above
+            const srcType = (model as ModelWithSource).srcType;
+            const srcProjectId = (model as ModelWithSource).srcProjectId;
+            presetIdsForModel = presetsIdsByContentSourceAndModel[srcType]?.[srcProjectId]?.[model.name];
+        } else {
+            presetIdsForModel = presetsIdsByModel_deprecated[model.name];
+        }
         if (!presetIdsForModel) {
             return model;
         }
-        return { ...model, presets: presetIdsForModel };
+        return {
+            ...model,
+            presets: presetIdsForModel
+        };
     });
-
-    return {
-        config: Object.assign({}, config, {
-            models,
-            presets
-        }),
-        errors
-    };
 }
 
 function resolveThumbnailPath(thumbnail: string, dir: string) {

package/src/content/content-schema.ts

@@ -37,7 +37,7 @@ export function joiSchemasForModels(config: Config) {
         config.models,
         (modelSchemas: ModelSchemaMap, model: Model) => {
             let joiSchema: Joi.ObjectSchema;
-            if (model.type !== 'image' && model.__metadata?.invalid) {
+            if (model.__metadata?.invalid) {
                 // if root model is invalid, replace the label with "file" otherwise joi outputs "value" which is not descriptive
                 let objectLabel = '{{#label}}';
                 if (isDataModel(model) || isPageModel(model)) {

package/src/index.ts

@@ -6,8 +6,27 @@ export * from './config/config-errors';
 export * from './analyzer/file-browser';
 export * from './utils';
 export * from './config/config-loader-static';
-export { RawConfigWithPaths, findStackbitConfigFile, isStackbitYamlFile, convertToYamlConfig } from './config/config-loader-utils';
-export { loadConfig, loadConfigFromDir, extendConfig, ConfigLoaderOptions, ConfigLoaderResult, ConfigLoaderResultWithStop } from './config/config-loader';
+export { loadPresets, getPresetDirs, extendModelsWithPresetsIds } from './config/presets-loader';
+export {
+    RawConfigWithPaths,
+    StopConfigWatch,
+    findStackbitConfigFile,
+    isStackbitYamlFile,
+    convertToYamlConfig,
+    getYamlModelDirs,
+    loadYamlModelsFromFiles,
+    mergeConfigModelsWithModelsFromFiles
+} from './config/config-loader-utils';
+export {
+    loadConfig,
+    LoadConfigResult,
+    loadConfigWithModelsPresetsAndValidate,
+    ConfigWithModelsPresetsResult,
+    loadConfigFromDir,
+    RawConfigLoaderResult,
+    mergeConfigModelsWithExternalModels
+} from './config/config-loader';
+export { validateConfig } from './config/config-validator';
 export { writeConfig, WriteConfigOptions } 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

@@ -1,16 +1,4 @@
-type UnionKeys<U> = U extends any ? keyof U : never;
-
-type ForbiddenPropertiesOfUnionMember<T, Union, Keys extends string = UnionKeys<Union> extends string ? UnionKeys<Union> : never> = {
-    [k in Exclude<Keys, keyof T>]?: undefined;
-};
-
-type StricterUnionMember<T, Union, Keys extends string = UnionKeys<Union> extends string ? UnionKeys<Union> : never> = T &
-    ForbiddenPropertiesOfUnionMember<T, Union, Keys>;
-
-export type StricterUnion<Union, Union2 = Union> = Union2 extends any ? StricterUnionMember<Union2, Union> : never;
-
-export type Logger = Pick<Console, 'debug' | 'info' | 'warn' | 'error'>;
-
+export { Logger } from '@stackbit/types';
 export * from './model-utils';
 export * from './model-matcher';
 export * from './model-extender';

package/src/utils/model-extender.ts

@@ -95,7 +95,7 @@ function extendModel<T extends Model | YamlModel>(
         copyIfNotSet(extendedSuperModel, 'singleInstance', model, 'singleInstance');
         copyIfNotSet(extendedSuperModel, 'labelField', model, 'labelField');
         copyIfNotSet(extendedSuperModel, 'variantField', model, 'variantField');
-        if (model.type !== 'image' && Array.isArray(extendedSuperModel.fieldGroups) && extendedSuperModel.fieldGroups.length > 0) {
+        if (Array.isArray(extendedSuperModel.fieldGroups) && extendedSuperModel.fieldGroups.length > 0) {
             _.set(model, 'fieldGroups', _.uniqBy(_.concat(extendedSuperModel.fieldGroups, _.get(model, 'fieldGroups', [])), 'name'));
         }
         let idx = 0;

package/src/utils/model-iterators.ts

@@ -1,8 +1,9 @@
 import _ from 'lodash';
-
 import { mapPromise, mapValuesPromise } from '@stackbit/utils';
+import { Field, FieldList, FieldListItems, FieldModelProps, FieldObjectProps } from '@stackbit/types';
+
 import { getListFieldItems, isListDataModel, isListField, isObjectListItems, isModelField, isObjectField, isModelListItems } from './model-utils';
-import { Model, YamlModel, DataModel, Field, FieldList, FieldListItems, FieldModelProps, FieldObjectProps } from '../config/config-types';
+import { Model, YamlModel, DataModel  } from '../config/config-types';
 
 /**
  * This function invokes the `iteratee` function for every field of the `model`.
@@ -76,7 +77,7 @@ export function iterateModelFieldsRecursively(model: Model | YamlModel, iteratee
     }
 }
 
-export function mapModelFieldsRecursively(model: Model, iteratee: (field: Field, modelKeyPath: string[]) => Field) {
+export function mapModelFieldsRecursively<T extends Model>(model: T, iteratee: (field: Field, modelKeyPath: string[]) => Field): T {
     function _mapField(field: Field, modelKeyPath: string[]): Field {
         if (!field) {
             return field;
@@ -92,7 +93,7 @@ export function mapModelFieldsRecursively(model: Model, iteratee: (field: Field,
         }
     }
 
-    function _mapObjectField<T extends FieldObjectProps | Model>(field: T, modelKeyPath: string[]): T {
+    function _mapObjectField<Y extends FieldObjectProps | T>(field: Y, modelKeyPath: string[]): Y {
         const fields = field.fields;
         if (!fields) {
             return field;
@@ -104,7 +105,7 @@ export function mapModelFieldsRecursively(model: Model, iteratee: (field: Field,
         };
     }
 
-    function _mapListField<T extends FieldList | (DataModel & { isList: true })>(field: T, modelKeyPath: string[]): T {
+    function _mapListField<Y extends FieldList | (T & { type: 'data'; isList: true })>(field: Y, modelKeyPath: string[]): Y {
         const items = field.items;
         if (!items || !isObjectListItems(items)) {
             return field;

package/src/utils/model-utils.ts

@@ -7,14 +7,15 @@ import {
     DataModel,
     PageModel,
     ConfigModel,
-    ImageModel,
     YamlModel,
     YamlObjectModel,
     YamlPageModel,
     YamlDataModel,
     YamlDataModelList,
     Field,
+    FieldSpecificProps,
     FieldEnum,
+    FieldEnumProps,
     FieldList,
     FieldListItems,
     FieldListModel,
@@ -26,7 +27,8 @@ import {
     FieldObjectProps,
     FieldReference,
     FieldReferenceProps,
-    DataModelList
+    DataModelList,
+    FieldListProps
 } from '../config/config-types';
 
 export function getModelByName(models: Model[], modelName: string): Model | undefined {
@@ -53,10 +55,6 @@ export function isObjectModel(model: Model | YamlModel): model is ObjectModel |
     return model.type === 'object';
 }
 
-export function isImageModel(model: Model): model is ImageModel {
-    return model.type === 'image';
-}
-
 export function isSingleInstanceModel(model: Model | YamlModel): boolean {
     if (model.type === 'config') {
         return true;
@@ -68,24 +66,24 @@ export function isSingleInstanceModel(model: Model | YamlModel): boolean {
     return false;
 }
 
-export function isObjectField(field: Field): field is FieldObject {
+export function isObjectField(field: FieldSpecificProps): field is FieldObjectProps {
     return field.type === 'object';
 }
 
-export function isModelField(field: Field): field is FieldModel {
+export function isModelField(field: FieldSpecificProps): field is FieldModelProps {
     return field.type === 'model';
 }
 
-export function isReferenceField(field: Field): field is FieldReference {
+export function isReferenceField(field: FieldSpecificProps): field is FieldReferenceProps {
     return field.type === 'reference';
 }
 
-export function isCustomModelField(field: Field, modelsByName: Record<string, Model>) {
+export function isCustomModelField(field: FieldSpecificProps, modelsByName: Record<string, Model>) {
     // custom model field types are deprecated
     return !FIELD_TYPES.includes(field.type) && _.has(modelsByName, field.type);
 }
 
-export function isEnumField(field: Field): field is FieldEnum {
+export function isEnumField(field: FieldSpecificProps): field is FieldEnumProps {
     return field.type === 'enum';
 }
 
@@ -157,19 +155,21 @@ export function getListFieldItems(field: FieldList): FieldListItems {
 }
 
 export function normalizeListField(field: FieldList): FieldList {
-    if (field.items?.type) {
+    // in older versions, the list 'items' were optional and when weren't
+    // specified a default list of strings was used.
+    if (_.get(field, 'items.type')) {
         return field;
     }
     return {
         ...field,
         items: {
-            type: 'string',
-            ...(field.items ?? {})
+            ...(field.items ?? {}),
+            type: 'string'
         }
-    };
+    } as FieldList;
 }
 
-export function normalizeListFieldInPlace(field: FieldList): FieldList {
+export function normalizeListFieldInPlace(field: FieldList | DataModelList): FieldList | DataModelList {
     // 'items.type' of list field default to 'string', set it explicitly
     if (!_.has(field, 'items.type')) {
         _.set(field, 'items.type', 'string');
@@ -177,6 +177,28 @@ export function normalizeListFieldInPlace(field: FieldList): FieldList {
     return field;
 }
 
+export function getListItemsOrSelf(field: Field): Exclude<FieldSpecificProps, FieldListProps> {
+    if (isListField(field)) {
+        return normalizeListField(field).items;
+    }
+    return field;
+}
+
+export function mapListItemsPropsOrSelfSpecificProps(
+    field: Field,
+    func: <T extends Exclude<FieldSpecificProps, FieldListProps>>(listItemsPropsOrField: T) => T
+): Field {
+    if (isListField(field)) {
+        const listItems = normalizeListField(field).items;
+        const mappedListItems = func(listItems);
+        return {
+            ...field,
+            items: mappedListItems
+        } as FieldList;
+    }
+    return func(field);
+}
+
 export function assignLabelFieldIfNeeded(modelOrField: Model | FieldObjectProps) {
     if (modelOrField.labelField) {
         return;