improved API

Author: schickling

.yarn/releases/yarn-3.2.2.cjs renamed to .yarn/releases/yarn-3.2.3.cjs

@@ -16,4 +16,4 @@ plugins:
   - path: .yarn/plugins/@yarnpkg/plugin-version.cjs
     spec: "@yarnpkg/plugin-version"
 
-yarnPath: .yarn/releases/yarn-3.2.2.cjs
+yarnPath: .yarn/releases/yarn-3.2.3.cjs

.yarnrc.yml

@@ -47,5 +47,5 @@
     "next-contentlayer": "workspace:*",
     "rxjs": "^7.1.0"
   },
-  "packageManager": "[email protected].2"
+  "packageManager": "[email protected].3"
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentlayer/cli",
-  "version": "0.2.8-dev.5",
+  "version": "0.2.8-dev.8",
   "type": "module",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",

packages/@contentlayer/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentlayer/client",
-  "version": "0.2.8-dev.5",
+  "version": "0.2.8-dev.8",
   "type": "module",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",

packages/@contentlayer/client/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentlayer/core",
-  "version": "0.2.8-dev.5",
+  "version": "0.2.8-dev.8",
   "type": "module",
   "exports": "./dist/index.js",
   "types": "./dist/index.d.ts",

packages/@contentlayer/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contentlayer/experimental-source-files-stackbit",
-  "version": "0.2.8-dev.5",
+  "version": "0.2.8-dev.8",
   "type": "module",
   "exports": {
     ".": {

packages/@contentlayer/experimental-source-files-stackbit/package.json

@@ -1,44 +1,54 @@
-import * as SourceFiles from '@contentlayer/source-files'
-import { casesHandled, isReadonlyArray, not, notImplemented, partition, pick } from '@contentlayer/utils'
-import { identity } from '@contentlayer/utils/effect'
+import type { GetDocumentTypeNamesGen } from '@contentlayer/core'
+import type * as SourceFiles from '@contentlayer/source-files'
+import { defineDocumentType } from '@contentlayer/source-files'
+import { not, partition } from '@contentlayer/utils'
 import * as Stackbit from '@stackbit/sdk'
 import { validateAndNormalizeConfig } from '@stackbit/sdk/dist/config/config-loader.js'
 
-export { addComputedFields } from './addComputedFields.js'
+import type { SharedCtx } from './mapping.js'
+import { stackbitDocumentLikeModelToDocumentType, stackbitObjectModelToDocumentType } from './mapping.js'
 
-type DocumentTypeMap = Record<string, SourceFiles.DocumentType>
-type NestedTypeMap = Record<string, SourceFiles.NestedType>
-type SharedCtx = {
-  documentTypeMap: DocumentTypeMap
-  nestedTypeMap: NestedTypeMap
+export type ContentlayerOverrideArgs<TDocumentTypeNames extends string> = {
+  documentTypes: Partial<{
+    [TDocumentTypeName in TDocumentTypeNames]: ContentlayerOverrideDocumentType<TDocumentTypeName>
+  }>
+}
+
+export type ContentlayerOverrideDocumentType<TDocumentTypeName extends string> = {
+  filePathPattern?: string
+  computedFields?: SourceFiles.ComputedFields<TDocumentTypeName>
 }
 
 /**
  * @example
  * ```ts
+ * // contentlayer.config.ts
  * import { makeSource } from 'contentlayer/source-files'
  * import { loadStackbitConfigAsDocumentTypes } from '@contentlayer/experimental-source-files-stackbit'
  *
+ * // Looks for `stackbit.yaml` in the current directory
  * export default loadStackbitConfigAsDocumentTypes().then((documentTypes) => {
  *   return makeSource({ contentDirPath: 'content', documentTypes })
  * })
  * ```
  */
-export const loadStackbitConfigAsDocumentTypes = (
+export const loadStackbitConfigAsDocumentTypes = <TDocumentTypeNames extends GetDocumentTypeNamesGen>(
   options: Stackbit.ConfigLoaderOptions = { dirPath: '' },
+  overrideArgs: ContentlayerOverrideArgs<TDocumentTypeNames> = { documentTypes: {} },
 ): Promise<SourceFiles.DocumentType[]> =>
   Stackbit.loadConfig(options).then((configResult) => {
     if (configResult.errors.length > 0) {
       throw new Error(configResult.errors.join('\n'))
     }
 
-    return stackbitConfigToDocumentTypes(configResult.config!)
+    return stackbitConfigToDocumentTypes(configResult.config!, overrideArgs)
   })
 
 /**
  *
  * @example
  * ```ts
+ * // contentlayer.config.ts
  * import { makeSource } from 'contentlayer/source-files'
  * import { stackbitConfigToDocumentTypes } from '@contentlayer/source-files-stackbit'
  * import stackbitConfig from './stackbit.config.js'
@@ -48,8 +58,9 @@ export const loadStackbitConfigAsDocumentTypes = (
  * export default makeSource({ contentDirPath: 'content', documentTypes })
  * ```
  */
-export const stackbitConfigToDocumentTypes = (
+export const stackbitConfigToDocumentTypes = <TDocumentTypeNames extends GetDocumentTypeNamesGen>(
   stackbitConfig: Stackbit.Config | Stackbit.YamlConfig,
+  overrideArgs: ContentlayerOverrideArgs<TDocumentTypeNames> = { documentTypes: {} },
 ): SourceFiles.DocumentType[] => {
   const validatedStackbitConfig = validateStackbitConfig(stackbitConfig)
 
@@ -68,12 +79,26 @@ export const stackbitConfigToDocumentTypes = (
   })
 
   documentTypes.forEach((documentType) => {
-    ctx.documentTypeMap[documentType.def().name] = documentType
+    const documentTypeName = documentType.def().name
+    ctx.documentTypeMap[documentTypeName] = documentType
+
+    const documentOverride = (overrideArgs.documentTypes as any)[documentTypeName]
+    if (documentOverride) {
+      patchDocumentType(documentType, documentOverride)
+    }
   })
 
   return documentTypes
 }
 
+const patchDocumentType = (
+  documentType: SourceFiles.DocumentType,
+  patch: Partial<SourceFiles.DocumentTypeDef>,
+): void => {
+  const previousDef = documentType.def()
+  documentType.def = defineDocumentType(() => ({ ...previousDef, ...patch })).def
+}
+
 const validateStackbitConfig = (stackbitConfig: Stackbit.Config | Stackbit.YamlConfig): Stackbit.Config => {
   if (Array.isArray(stackbitConfig.models)) {
     return stackbitConfig as Stackbit.Config
@@ -88,190 +113,9 @@ const validateStackbitConfig = (stackbitConfig: Stackbit.Config | Stackbit.YamlC
   return stackbitConfigResult.config
 }
 
-const stackbitDocumentLikeModelToDocumentType =
-  (ctx: SharedCtx) =>
-  (stackbitModel: Stackbit.PageModel | Stackbit.DataModel | Stackbit.ConfigModel): SourceFiles.DocumentType => {
-    return SourceFiles.defineDocumentType(() => ({
-      name: stackbitModel.name,
-      description: stackbitModel.description,
-      fields: (stackbitModel.fields ?? []).map(stackbitFieldToField(ctx)),
-      isSingleton: stackbitModel.type === 'config' || stackbitModel.singleInstance === true,
-    }))
-  }
-
-const stackbitObjectModelToDocumentType =
-  (ctx: SharedCtx) =>
-  (stackbitModel: Stackbit.ObjectModel): SourceFiles.NestedType => {
-    return SourceFiles.defineNestedType(() => ({
-      name: stackbitModel.name,
-      description: stackbitModel.description,
-      fields: (stackbitModel.fields ?? []).map(stackbitFieldToField(ctx)),
-    }))
-  }
-
-const stackbitFieldToField =
-  (ctx: SharedCtx) =>
-  (stackbitField: Stackbit.Field): SourceFiles.FieldDefWithName => {
-    const commonFields = {
-      ...pick(stackbitField, ['name', 'description', 'required']),
-      default: stackbitField.default as any,
-    }
-
-    type WithName<T> = T & { name: string }
-
-    switch (stackbitField.type) {
-      case 'boolean':
-      case 'number':
-        type FieldDef = SourceFiles.BooleanFieldDef | SourceFiles.NumberFieldDef
-        return identity<WithName<FieldDef>>({ ...commonFields, type: stackbitField.type })
-      case 'enum':
-        return identity<WithName<SourceFiles.EnumFieldDef>>({
-          ...commonFields,
-          type: 'enum',
-          options: stackbitField.options.map(mapStackbitEnumOption),
-        })
-      case 'style':
-        return identity<WithName<SourceFiles.JSONFieldDef>>({ ...commonFields, type: 'json' })
-      case 'list': {
-        const of = stackbitListItemToListFieldDef(ctx)(stackbitField.items!)
-        return isReadonlyArray(of)
-          ? identity<WithName<SourceFiles.ListPolymorphicFieldDef>>({
-              ...commonFields,
-              type: 'list',
-              of,
-              typeField: 'type',
-            })
-          : identity<WithName<SourceFiles.ListFieldDef>>({ ...commonFields, type: 'list', of })
-      }
-      case 'reference': {
-        const of = stackbitField.models.map((modelName) => ctx.documentTypeMap[modelName]!)
-        if (of.length === 1) {
-          return identity<WithName<SourceFiles.ReferenceFieldDef>>({ ...commonFields, type: 'reference', of: of[0]! })
-        }
-        return identity<WithName<SourceFiles.ReferencePolymorphicFieldDef>>({
-          ...commonFields,
-          type: 'reference',
-          of,
-          typeField: 'type',
-        })
-      }
-      case 'model': {
-        const of = stackbitField.models.map((modelName) => ctx.nestedTypeMap[modelName]!)
-        if (of.length === 1) {
-          return identity<WithName<SourceFiles.NestedFieldDef>>({ ...commonFields, type: 'nested', of: of[0]! })
-        }
-        return identity<WithName<SourceFiles.NestedPolymorphicFieldDef>>({
-          ...commonFields,
-          type: 'nested',
-          of,
-          typeField: 'type',
-        })
-      }
-      case 'object': {
-        const unnamedNestedTypeDef = identity<SourceFiles.NestedUnnamedTypeDef>({
-          fields: stackbitField.fields.map(stackbitFieldToField(ctx)),
-        })
-        return identity<WithName<SourceFiles.NestedFieldDef>>({
-          ...commonFields,
-          type: 'nested',
-          of: { type: 'nested', def: () => unnamedNestedTypeDef },
-        })
-      }
-      case 'markdown':
-        return identity<WithName<SourceFiles.MarkdownFieldDef>>({ ...commonFields, type: 'markdown' })
-      case 'json':
-        return identity<WithName<SourceFiles.JSONFieldDef>>({ ...commonFields, type: 'json' })
-      case 'image':
-        return identity<WithName<SourceFiles.ImageFieldDef>>({ ...commonFields, type: 'image' })
-      case 'datetime':
-      case 'date':
-        return identity<WithName<SourceFiles.DateFieldDef>>({ ...commonFields, type: 'date' })
-      case 'string':
-      case 'url':
-      case 'text':
-      case 'color':
-      case 'slug':
-      case 'html':
-      case 'file':
-        return identity<WithName<SourceFiles.StringFieldDef>>({ ...commonFields, type: 'string' })
-      case 'richText':
-        notImplemented(`richText doesn't exist in the "files" content source`)
-      default:
-        casesHandled(stackbitField)
-    }
-  }
-
-const stackbitListItemToListFieldDef =
-  (ctx: SharedCtx) =>
-  (
-    stackbitListItem: Stackbit.FieldListItems,
-  ): SourceFiles.ListFieldDefItem.Item | readonly SourceFiles.ListFieldDefItem.Item[] => {
-    switch (stackbitListItem.type) {
-      case 'boolean':
-      case 'string':
-      case 'number':
-        type Item =
-          | SourceFiles.ListFieldDefItem.ItemString
-          | SourceFiles.ListFieldDefItem.ItemBoolean
-          | SourceFiles.ListFieldDefItem.ItemNumber
-        return identity<Item>({ type: stackbitListItem.type })
-      case 'enum':
-        return identity<SourceFiles.ListFieldDefItem.ItemEnum>({
-          type: 'enum',
-          options: stackbitListItem.options.map(mapStackbitEnumOption),
-        })
-      case 'reference':
-        return firstArrayItemIfOne(
-          stackbitListItem.models.map((modelName) =>
-            identity<SourceFiles.ListFieldDefItem.ItemDocumentReference>(ctx.documentTypeMap[modelName]!),
-          ),
-        )
-      case 'model':
-        return firstArrayItemIfOne(
-          stackbitListItem.models.map((modelName) =>
-            identity<SourceFiles.ListFieldDefItem.ItemNestedType>(ctx.nestedTypeMap[modelName]!),
-          ),
-        )
-      case 'object':
-        return identity<SourceFiles.ListFieldDefItem.ItemNestedType>({
-          type: 'nested',
-          def: () => ({ fields: stackbitListItem.fields.map(stackbitFieldToField(ctx)) }),
-        })
-      case 'date':
-      case 'datetime':
-        return identity<SourceFiles.ListFieldDefItem.ItemDate>({ type: 'date' })
-      case 'json':
-        return identity<SourceFiles.ListFieldDefItem.ItemJSON>({ type: 'json' })
-      case 'markdown':
-        return identity<SourceFiles.ListFieldDefItem.ItemMarkdown>({ type: 'markdown' })
-      case 'image':
-        return identity<SourceFiles.ListFieldDefItem.ItemImage>({ type: 'image' })
-      case 'url':
-      case 'text':
-      case 'color':
-      case 'slug':
-      case 'html':
-      case 'file':
-        return identity<SourceFiles.ListFieldDefItem.ItemString>({ type: 'string' })
-      case 'richText':
-        notImplemented(`richText doesn't exist in the "files" content source`)
-      default:
-        casesHandled(stackbitListItem)
-    }
-  }
-
-const mapStackbitEnumOption = (option: Stackbit.FieldEnumOptionValue | Stackbit.FieldEnumOptionObject): string => {
-  if (typeof option === 'string' || typeof option === 'number') {
-    return option.toString()
-  }
-  return option.value.toString()
-}
-
 const isDocumentLikeModel = (
   model: Stackbit.Model,
 ): model is Stackbit.PageModel | Stackbit.DataModel | Stackbit.ConfigModel =>
   model.type === 'data' || model.type === 'page' || model.type === 'config'
 
 const isImageModel = (model: Stackbit.Model): model is Stackbit.ImageModel => model.type === 'image'
-
-const firstArrayItemIfOne = <T>(array: readonly T[]): T | readonly T[] => (array.length === 1 ? array[0]! : array)