@stackbit/sdk 0.3.3-alpha.1 → 0.3.3-alpha.2

package/src/config/config-types.ts

@@ -1,136 +1,72 @@
-import { StricterUnion } from '../utils';
-import { CMS_NAMES, FIELD_TYPES, SSG_NAMES, STYLE_PROPS } from './config-consts';
-
-export interface Config extends BaseConfig {
-    stackbitVersion: string;
+import {
+    StackbitConfig,
+    ObjectModel as StackbitConfigObjectModel,
+    ConfigModel as StackbitConfigConfigModel,
+    PageModel as StackbitConfigPageModel,
+    DataModel as StackbitConfigDataModel,
+    ModelCommonFields,
+    Field,
+    FieldListItems
+} from '@stackbit/types';
+
+// re-export types for backward compatibility
+export {
+    StackbitConfig as RawConfig,
+    Import,
+    ContentfulImport,
+    SanityImport,
+    ContentModelMap,
+    ContentModel,
+    PresetSource,
+    PresetSourceFiles,
+    ModelsSource,
+    ModelsSourceFiles,
+    ModelsSourceContentful,
+    ModelsSourceSanity,
+    Field,
+    FieldType,
+    FieldSpecificProps,
+    FieldCommonProps,
+    FieldBasic as FieldSimple,
+    FieldEnum,
+    FieldImage,
+    FieldNumber,
+    FieldObject,
+    FieldModel,
+    FieldReference,
+    FieldStyle,
+    FieldList,
+    FieldListObject,
+    FieldListModel,
+    FieldListReference,
+    FieldBasicProps as FieldSimpleProps,
+    FieldEnumProps,
+    FieldEnumDropdownProps,
+    FieldEnumThumbnailsProps,
+    FieldEnumPaletteProps,
+    FieldEnumOptionValue,
+    FieldEnumOptionObject,
+    FieldEnumOptionThumbnails,
+    FieldEnumOptionPalette,
+    FieldImageProps,
+    FieldNumberProps,
+    FieldObjectProps,
+    FieldGroupItem,
+    FieldModelProps,
+    FieldReferenceProps,
+    StyleProps,
+    FieldStyleProps,
+    FieldListProps,
+    FieldListItems
+} from '@stackbit/types';
+
+export interface Config extends Omit<StackbitConfig, 'models' | 'customContentReload' | 'experimental'> {
+    dirPath: string;
+    filePath: string;
     models: Model[];
     presets?: Record<string, Preset>;
-    hcrHandled?: boolean;
     internalStackbitRunnerOptions?: SSGRunOptions;
-    dirPath: string;
-    filePath: string;
-}
-
-export interface RawConfig extends BaseConfig {
-    stackbitVersion?: string;
-    models?: ModelMap;
-}
-
-interface BaseConfig {
-    ssgName?: typeof SSG_NAMES[number];
-    ssgVersion?: string;
-    nodeVersion?: string;
-    postGitCloneCommand?: string;
-    preInstallCommand?: string;
-    postInstallCommand?: string;
-    devCommand?: string;
-    cmsName?: typeof CMS_NAMES[number];
-    import?: Import;
-    buildCommand?: string;
-    publishDir?: string;
-    staticDir?: string;
-    uploadDir?: string;
-    assets?: Assets;
-    pagesDir?: string | null;
-    dataDir?: string | null;
-    pageLayoutKey?: string | null;
-    objectTypeKey?: string;
-    styleObjectModelName?: string | null;
-    excludePages?: string | string[];
-    logicFields?: LogicField[];
-    contentModels?: ContentModelMap;
-    presetSource?: PresetSource;
-    modelsSource?: ModelsSource;
-    presetReferenceBehavior?: 'copyReference' | 'duplicateContents';
-    nonDuplicatableModels?: string[];
-    duplicatableModels?: string[];
-    contentSources?: any[]; // TODO: set to ContentSourceInterface[], move it to @stackbit/types first
-    mapModels?: (options: { models: Model[]; contentSourceType: string; contentSourceProjectId: string }) => Model[];
-
-    // DEPRECATED
-    noEncodeFields?: string[]; // DEPRECATED, for backward compatibility and typescript support
-    omitFields?: string[]; // DEPRECATED, for backward compatibility and typescript support
-    encodedFieldTypes?: string[]; // DEPRECATED, for backward compatibility and typescript support
-}
-
-export type Import = ContentfulImport | SanityImport;
-
-export interface ContentfulImport {
-    type: 'contentful';
-    contentFile: string;
-    uploadAssets?: boolean;
-    assetsDirectory?: string;
-    spaceIdEnvVar?: string;
-    accessTokenEnvVar?: string;
-    deliveryTokenEnvVar?: string;
-    previewTokenEnvVar?: string;
-}
-
-export interface SanityImport {
-    type: 'sanity';
-    contentFile: string;
-    sanityStudioPath: string;
-    deployStudio?: boolean;
-    deployGraphql?: boolean;
-    projectIdEnvVar?: string;
-    datasetEnvVar?: string;
-    tokenEnvVar?: string;
-}
-
-export type Assets = StricterUnion<StaticAssets | RelativeAssets>;
-
-export interface StaticAssets {
-    referenceType: 'static';
-    assetsDir?: string;
-    staticDir: string;
-    publicPath: string;
-    uploadDir?: string;
-}
-
-export interface RelativeAssets {
-    referenceType: 'relative';
-    assetsDir: string;
-    staticDir?: string;
-    publicPath?: string;
-    uploadDir?: string;
-}
-
-export type LogicField = string;
-
-export type ContentModelMap = Record<string, ContentModel>;
-
-export interface ContentModel extends BaseMatch {
-    isPage?: boolean;
-    urlPath?: string;
-    hideContent?: boolean;
-    newFilePath?: string;
-}
-
-export type PresetSource = PresetSourceFiles;
-
-export interface PresetSourceFiles {
-    type: 'files';
-    presetDirs: string[];
-}
-
-export type ModelsSource = ModelsSourceFiles | ModelsSourceContentful | ModelsSourceSanity;
-
-export interface ModelsSourceFiles {
-    type: 'files';
-    modelDirs: string[];
-}
-
-export interface ModelsSourceContentful {
-    type: 'contentful';
-    module?: string;
-    [key: string]: any;
-}
-
-export interface ModelsSourceSanity {
-    type: 'sanity';
-    sanityStudioPath: string;
-    module?: string;
-    [key: string]: any;
+    hcrHandled?: boolean;
 }
 
 export interface Preset {
@@ -151,235 +87,68 @@ export interface SSGRunOptions {
     };
 }
 
-/*******************
- *** Model Types ***
- *******************/
-
-export type Model = StricterUnion<ObjectModel | DataModel | PageModel | ConfigModel | ImageModel>;
-
-export type ObjectModel = YamlObjectModel & BaseModel;
-export type DataModel = YamlDataModel & BaseModel;
-export type PageModel = YamlPageModel & BaseModel;
-export type ConfigModel = YamlConfigModel & BaseModel;
-
-export type BaseModel = {
-    name: string;
-    presets?: string[];
-};
-
-export type ModelMap = Record<string, YamlModel>;
-
-export type YamlModel = StricterUnion<YamlObjectModel | YamlDataModel | YamlPageModel | YamlConfigModel>;
-
-export interface YamlBaseModel {
-    type: 'object' | 'data' | 'page' | 'config';
-    __metadata?: {
-        filePath?: string;
-        invalid?: boolean;
-    };
-    label?: string;
-    description?: string;
-    thumbnail?: string;
-    extends?: string | string[];
-    readOnly?: boolean;
-    labelField?: string;
-    variantField?: string;
-    groups?: string[];
-    fieldGroups?: FieldGroupItem[];
-    fields?: Field[];
-}
-
-interface BaseMatch {
-    singleInstance?: boolean;
-    file?: string;
-    folder?: string;
-    match?: string | string[];
-    exclude?: string | string[];
-}
+/******************************
+ *** Normalized Model Types ***
+ ******************************/
 
-export interface YamlObjectModel extends YamlBaseModel {
-    type: 'object';
-}
+export type Model = ObjectModel | DataModel | PageModel | ConfigModel | ImageModel;
 
-export interface BaseDataModel extends YamlBaseModel, BaseMatch {
-    type: 'data';
-    filePath?: string;
-}
-
-export interface YamlPageModel extends YamlBaseModel, BaseMatch {
-    type: 'page';
-    layout?: string;
-    urlPath?: string;
-    filePath?: string;
-    hideContent?: boolean;
-}
-
-export interface YamlConfigModel extends YamlBaseModel {
-    type: 'config';
-    file?: string;
-}
-
-export type YamlDataModel = StricterUnion<BaseDataModelFields | BaseDataModeList>;
-
-export interface BaseDataModelFields extends BaseDataModel {
-    isList?: false;
-}
-
-export interface BaseDataModeList extends Omit<BaseDataModel, 'fields'> {
-    isList: true;
-    items: FieldListItems;
-}
-
-export interface FieldGroupItem {
-    name: string;
-    label: string;
-    icon?: string;
-}
-
-export interface ImageModel {
+export type ObjectModel = StackbitConfigObjectModel & BaseModel;
+export type DataModel = DataModelSingle | DataModelList;
+export type PageModel = StackbitConfigPageModel & BaseModel;
+export type ConfigModel = StackbitConfigConfigModel & BaseModel;
+export type ImageModel = {
     type: 'image';
     name: '__image_model';
     label?: string;
     labelField?: string;
     fields?: Field[];
     source?: string;
-}
-
-/*******************
- *** Field Types ***
- *******************/
-
-export type Field = FieldSimple | FieldEnum | FieldImage | FieldNumber | FieldObject | FieldModel | FieldReference | FieldStyle | FieldList;
-
-export type FieldSpecificProps =
-    | FieldSimpleProps
-    | FieldEnumProps
-    | FieldImageProps
-    | FieldNumberProps
-    | FieldObjectProps
-    | FieldModelProps
-    | FieldReferenceProps
-    | FieldStyleProps
-    | FieldListProps;
-
-export type FieldSimple = FieldCommonProps & FieldSimpleProps;
-export type FieldEnum = FieldCommonProps & FieldEnumProps;
-export type FieldImage = FieldCommonProps & FieldImageProps;
-export type FieldNumber = FieldCommonProps & FieldNumberProps;
-export type FieldObject = FieldCommonProps & FieldObjectProps;
-export type FieldModel = FieldCommonProps & FieldModelProps;
-export type FieldReference = FieldCommonProps & FieldReferenceProps;
-export type FieldStyle = FieldCommonProps & FieldStyleProps;
-export type FieldList = FieldCommonProps & FieldListProps;
-
-export type FieldListObject = FieldList & { items?: FieldObjectProps };
-export type FieldListModel = FieldList & { items?: FieldModelProps };
-export type FieldListReference = FieldList & { items?: FieldReferenceProps };
-
-export interface FieldCommonProps {
-    type: FieldType;
-    name: string;
-    label?: string;
-    description?: string;
-    required?: boolean;
-    default?: unknown;
-    group?: string;
-    const?: unknown;
-    hidden?: boolean;
-    readOnly?: boolean;
-    localized?: boolean;
-}
-
-export type FieldType = typeof FIELD_TYPES[number];
-
-export interface FieldSimpleProps {
-    type: 'string' | 'url' | 'slug' | 'text' | 'markdown' | 'html' | 'boolean' | 'date' | 'datetime' | 'color' | 'file' | 'json' | 'richText';
-}
-
-export type FieldEnumProps = FieldEnumDropdownProps | FieldEnumThumbnailsProps | FieldEnumPaletteProps;
-
-export interface FieldEnumDropdownProps {
-    type: 'enum';
-    controlType?: 'dropdown' | 'button-group';
-    options: FieldEnumOptionValue[] | FieldEnumOptionObject[];
-}
+};
 
-export interface FieldEnumThumbnailsProps {
-    type: 'enum';
-    controlType: 'thumbnails';
-    options: FieldEnumOptionThumbnails[];
+export interface DataModelSingle extends StackbitConfigDataModel, BaseModel {
+    isList?: false;
 }
 
-export interface FieldEnumPaletteProps {
-    type: 'enum';
-    controlType: 'palette';
-    options: FieldEnumOptionPalette[];
+export interface DataModelList extends StackbitConfigDataModel, BaseModel {
+    isList: true;
+    items: FieldListItems;
 }
 
-export type FieldEnumOptionValue = string | number;
+type BaseModel = ModelMetadata & { presets?: string[] };
 
-export interface FieldEnumOptionObject {
-    label: string;
-    value: FieldEnumOptionValue;
+interface ModelMetadata {
+    __metadata?: {
+        filePath?: string;
+        invalid?: boolean;
+    };
 }
 
-export interface FieldEnumOptionThumbnails extends FieldEnumOptionObject {
-    thumbnail?: string;
-}
+/***********************
+ *** Raw Model Types ***
+ ***********************/
 
-export interface FieldEnumOptionPalette extends FieldEnumOptionObject {
-    textColor?: string;
-    backgroundColor?: string;
-    borderColor?: string;
-}
+export type YamlModel = YamlObjectModel | YamlPageModel | YamlConfigModel | YamlDataModel;
 
-export interface FieldImageProps {
-    type: 'image';
-    source?: string;
-}
+export type YamlModelMap = Record<string, YamlModel>;
 
-export interface FieldNumberProps {
-    type: 'number';
-    controlType?: 'slider';
-    subtype?: 'int' | 'float';
-    min?: number;
-    max?: number;
-    step?: number;
-    unit?: string;
+export interface YamlBaseModel extends Omit<ModelCommonFields, 'name'>, ModelMetadata {
+    type: YamlModel['type'];
 }
 
-export interface FieldObjectProps {
-    type: 'object';
-    labelField?: string;
-    thumbnail?: string;
-    variantField?: string;
-    fieldGroups?: FieldGroupItem[];
-    fields: Field[];
-}
+export interface YamlObjectModel extends Omit<StackbitConfigObjectModel, 'name'>, ModelMetadata {}
 
-export interface FieldModelProps {
-    type: 'model';
-    models: string[];
-    groups?: string[];
-}
+export interface YamlPageModel extends Omit<StackbitConfigPageModel, 'name'>, ModelMetadata {}
 
-export interface FieldReferenceProps {
-    type: 'reference';
-    models: string[];
-    groups?: string[];
-}
+export interface YamlConfigModel extends Omit<StackbitConfigConfigModel, 'name'>, ModelMetadata {}
 
-export type StyleProps = typeof STYLE_PROPS[number];
+export type YamlDataModel = YamlDataModelSingle | YamlDataModelList;
 
-export interface FieldStyleProps {
-    type: 'style';
-    styles: Record<string, Partial<Record<StyleProps, any>>>;
+export interface YamlDataModelSingle extends Omit<StackbitConfigDataModel, 'name'>, ModelMetadata {
+    isList?: false;
 }
 
-export interface FieldListProps {
-    type: 'list';
-    items?: FieldListItems;
-    controlType?: 'checkbox';
+export interface YamlDataModelList extends Omit<StackbitConfigDataModel, 'name'>, ModelMetadata {
+    isList: true;
+    items: FieldListItems;
 }
-
-export type FieldListItems = FieldSimpleProps | FieldEnumProps | FieldImageProps | FieldNumberProps | FieldObjectProps | FieldModelProps | FieldReferenceProps;

package/src/config/config-validator.ts

@@ -1,10 +1,11 @@
 import _ from 'lodash';
 import Joi from 'joi';
+import { ContentModelMap } from '@stackbit/types';
 
 import { stackbitConfigSchema, contentModelsSchema } from './config-schema';
 import { ConfigValidationError } from './config-errors';
 import { RawConfigWithPaths } from './config-loader-utils';
-import { ContentModelMap, ModelMap } from './config-types';
+import { YamlModelMap } from './config-types';
 
 export interface ConfigValidationResult {
     value: RawConfigWithPaths;
@@ -26,7 +27,7 @@ export function validateConfig(config: RawConfigWithPaths): ConfigValidationResu
     };
 }
 
-export function validateContentModels(contentModels: ContentModelMap, models: ModelMap): ConfigValidationResult {
+export function validateContentModels(contentModels: ContentModelMap, models: YamlModelMap): ConfigValidationResult {
     const validationResult = contentModelsSchema.validate(
         { contentModels: contentModels },
         {

package/src/config/presets-loader.ts

@@ -90,6 +90,9 @@ export async function loadPresets(dirPath: string, config: Config): Promise<Pres
 }
 
 function resolveThumbnailPath(thumbnail: string, dir: string) {
+    if (thumbnail.startsWith('//') || /https?:\/\//.test(thumbnail)) {
+        return thumbnail;
+    }
     if (thumbnail.startsWith('/')) {
         if (dir.endsWith('@stackbit/components/presets')) {
             dir = dir.replace(/\/presets$/, '');

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.__metadata?.invalid) {
+            if (model.type !== 'image' && 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/utils/model-extender.ts

@@ -1,7 +1,7 @@
 import _ from 'lodash';
 import { copyIfNotSet } from '@stackbit/utils';
 
-import { Model, YamlModel, ModelMap } from '../config/config-types';
+import { Model, YamlModel, YamlModelMap } from '../config/config-types';
 import { ConfigValidationError } from '../config/config-errors';
 
 export function extendModelArray(models: Model[]): { models: Model[]; errors: ConfigValidationError[] } {
@@ -11,7 +11,7 @@ export function extendModelArray(models: Model[]): { models: Model[]; errors: Co
         models,
         (result: { models: Model[]; errors: ConfigValidationError[] }, model) => {
             // YamlModel is the same as Model just without 'name' and '__metadata' properties
-            const { model: extendedModel, errors } = memorized(model, model.name, modelsByName as ModelMap);
+            const { model: extendedModel, errors } = memorized(model, model.name, modelsByName as YamlModelMap);
             return {
                 models: result.models.concat(extendedModel),
                 errors: result.errors.concat(errors)
@@ -21,11 +21,11 @@ export function extendModelArray(models: Model[]): { models: Model[]; errors: Co
     );
 }
 
-export function extendModelMap(models?: ModelMap): { models: ModelMap; errors: ConfigValidationError[] } {
+export function extendModelMap(models?: YamlModelMap): { models: YamlModelMap; errors: ConfigValidationError[] } {
     const memorized = _.memoize(extendModel, (model, modelName) => modelName);
     return _.reduce(
         models,
-        (result: { models: ModelMap; errors: ConfigValidationError[] }, model, modelName) => {
+        (result: { models: YamlModelMap; errors: ConfigValidationError[] }, model, modelName) => {
             const { model: extendedModel, errors } = memorized(model, modelName, models!);
             return {
                 models: _.assign(result.models, { [modelName]: extendedModel }),
@@ -39,7 +39,7 @@ export function extendModelMap(models?: ModelMap): { models: ModelMap; errors: C
 function extendModel<T extends Model | YamlModel>(
     model: T,
     modelName: string,
-    modelsByName: ModelMap,
+    modelsByName: YamlModelMap,
     _extendPath: string[] = []
 ): { model: T; errors: ConfigValidationError[] } {
     if (_.includes(_extendPath, modelName)) {
@@ -63,7 +63,7 @@ function extendModel<T extends Model | YamlModel>(
         return { model, errors: [] };
     }
 
-    delete model['extends'];
+    _.unset(model, 'extends');
 
     if (!_.isArray(_extends)) {
         _extends = [_extends];
@@ -95,8 +95,8 @@ function extendModel<T extends Model | YamlModel>(
         copyIfNotSet(extendedSuperModel, 'singleInstance', model, 'singleInstance');
         copyIfNotSet(extendedSuperModel, 'labelField', model, 'labelField');
         copyIfNotSet(extendedSuperModel, 'variantField', model, 'variantField');
-        if (Array.isArray(extendedSuperModel.fieldGroups) && extendedSuperModel.fieldGroups.length > 0) {
-            model.fieldGroups = _.uniqBy(_.concat(extendedSuperModel.fieldGroups, _.get(model, 'fieldGroups', [])), 'name');
+        if (model.type !== 'image' && Array.isArray(extendedSuperModel.fieldGroups) && extendedSuperModel.fieldGroups.length > 0) {
+            _.set(model, 'fieldGroups', _.uniqBy(_.concat(extendedSuperModel.fieldGroups, _.get(model, 'fieldGroups', [])), 'name'));
         }
         let idx = 0;
         _.forEach(extendedSuperModel.fields, (superField) => {

package/src/utils/model-iterators.ts

@@ -2,7 +2,7 @@ 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';
+import { Model, YamlModel, DataModel, Field, FieldList, FieldListItems, FieldModelProps, FieldObjectProps } from '../config/config-types';
 
 /**
  * This function invokes the `iteratee` function for every field of the `model`.
@@ -40,7 +40,7 @@ import { DataModel, Field, FieldList, FieldListItems, FieldModelProps, FieldObje
  * @param model The model to iterate fields
  * @param iteratee The callback function
  */
-export function iterateModelFieldsRecursively(model: Model, iteratee: (field: Field, modelKeyPath: string[]) => void) {
+export function iterateModelFieldsRecursively(model: Model | YamlModel, iteratee: (field: Field, modelKeyPath: string[]) => void) {
     function _iterateDeep({ fields, modelKeyPath }: { fields: Field[]; modelKeyPath: string[] }) {
         modelKeyPath = modelKeyPath.concat('fields');
         _.forEach(fields, (field) => {

package/src/utils/model-matcher.ts

@@ -91,7 +91,7 @@ export function getModelsByQuery(query: ModelQuery, models: Model[]): Model[] {
     );
 
     const fileMatchedModels = _.filter(modelMatchGroups.byFile, (model) => {
-        if (!_.isString(model.file)) {
+        if (!('file' in model) || !_.isString(model.file)) {
             return false;
         }
         try {