feat: Index fields

packages/decap-cms-backend-github/src/API.ts

@@ -1391,32 +1391,41 @@ export default class API {
 
   async updateTree(
     baseSha: string,
-    files: { path: string; sha: string | null; newPath?: string }[],
+    files: { path: string; sha: string | null; newPath?: string; isFolder?: boolean }[],
     branch = this.branch,
   ) {
-    const toMove: { from: string; to: string; sha: string }[] = [];
+    const toMove: { from: string; to: string; sha: string; isFolder?: boolean }[] = [];
     const tree = files.reduce((acc, file) => {
       const entry = {
         path: trimStart(file.path, '/'),
         mode: '100644',
         type: 'blob',
         sha: file.sha,
+        isFolder: file.isFolder,
       } as TreeEntry;
 
       if (file.newPath) {
-        toMove.push({ from: file.path, to: file.newPath, sha: file.sha as string });
+        toMove.push({
+          from: file.path,
+          to: file.newPath,
+          sha: file.sha as string,
+          isFolder: file.isFolder,
+        });
       } else {
         acc.push(entry);
       }
 
       return acc;
     }, [] as TreeEntry[]);
 
-    for (const { from, to, sha } of toMove) {
+    for (const { from, to, sha, isFolder } of toMove) {
       const sourceDir = dirname(from);
       const destDir = dirname(to);
       const files = await this.listFiles(sourceDir, { branch, depth: 100 });
       for (const file of files) {
+        if (isFolder === false && file.path !== from) {
+          continue;
+        }
         // delete current path
         tree.push({
           path: file.path,

packages/decap-cms-core/index.d.ts

@@ -192,6 +192,7 @@ declare module 'decap-cms-core' {
     multiple?: boolean;
     min?: number;
     max?: number;
+    meta?: boolean;
   }
 
   export interface CmsFieldRelation {
@@ -334,6 +335,11 @@ declare module 'decap-cms-core' {
     view_filters?: ViewFilter[];
     view_groups?: ViewGroup[];
     i18n?: boolean | CmsI18nConfig;
+    index_file?: {
+      pattern: string;
+      editor?: { preview?: boolean };
+      fields?: CmsField[];
+    };
 
     /**
      * @deprecated Use sortable_fields instead

packages/decap-cms-core/src/actions/config.ts

@@ -23,10 +23,13 @@ import type {
   CmsFieldBase,
   CmsFieldObject,
   CmsFieldList,
+  CmsFieldSelect,
+  CmsFieldMeta,
   CmsI18nConfig,
   CmsPublishMode,
   CmsLocalBackend,
   State,
+  CmsCollectionMeta,
 } from '../types/redux';
 
 export const CONFIG_REQUEST = 'CONFIG_REQUEST';
@@ -206,6 +209,39 @@ export function normalizeConfig(config: CmsConfig) {
   return { ...config, collections: normalizedCollections };
 }
 
+function applyMetaFieldsToCollection(collection: CmsCollection, meta: CmsCollectionMeta) {
+  const metaFields: CmsFieldBase[] = [
+    {
+      name: 'path',
+      meta: true,
+      required: true,
+      i18n: 'duplicate',
+      default: '/',
+      ...meta!.path,
+    } as CmsFieldMeta,
+  ];
+
+  if (collection.index_file) {
+    metaFields.push({
+      name: 'path_type',
+      meta: true,
+      required: true,
+      widget: 'select',
+      readonly: true,
+      i18n: 'duplicate',
+      label: 'Path type',
+      options: ['index', 'slug'],
+      default: 'slug',
+    } as CmsFieldBase & CmsFieldSelect);
+  }
+
+  collection.fields = [...metaFields, ...(collection.fields || [])];
+
+  if (collection.index_file?.fields) {
+    collection.index_file.fields = [...metaFields, ...(collection.index_file.fields || [])];
+  }
+}
+
 export function applyDefaults(originalConfig: CmsConfig) {
   return produce(originalConfig, config => {
     config.publish_mode = config.publish_mode || SIMPLE_PUBLISH_MODE;
@@ -265,6 +301,13 @@ export function applyDefaults(originalConfig: CmsConfig) {
         collection.fields = setI18nDefaultsForFields(collection.fields, Boolean(collectionI18n));
       }
 
+      if (collection.index_file?.fields) {
+        collection.index_file.fields = setI18nDefaultsForFields(
+          collection.index_file.fields,
+          Boolean(collectionI18n),
+        );
+      }
+
       const { folder, files, view_filters, view_groups, meta } = collection;
 
       if (folder) {
@@ -286,13 +329,7 @@ export function applyDefaults(originalConfig: CmsConfig) {
         collection.folder = trim(folder, '/');
 
         if (meta && meta.path) {
-          const metaField = {
-            name: 'path',
-            meta: true,
-            required: true,
-            ...meta.path,
-          };
-          collection.fields = [metaField, ...(collection.fields || [])];
+          applyMetaFieldsToCollection(collection, meta);
         }
       }
 

packages/decap-cms-core/src/actions/entries.ts

@@ -16,11 +16,11 @@ import { SortDirection } from '../types/redux';
 import { waitForMediaLibraryToLoad, loadMedia } from './mediaLibrary';
 import { waitUntil } from './waitUntil';
 import { selectIsFetching, selectEntriesSortFields, selectEntryByPath } from '../reducers/entries';
-import { selectCustomPath } from '../reducers/entryDraft';
 import { navigateToEntry } from '../routing/history';
 import { getProcessSegment } from '../lib/formatters';
 import { hasI18n, duplicateDefaultI18nFields, serializeI18n, I18N, I18N_FIELD } from '../lib/i18n';
 import { addNotification } from './notifications';
+import { selectCustomPath } from '../reducers/entryDraft';
 
 import type { ImplementationMediaFile } from 'decap-cms-lib-util';
 import type { AnyAction } from 'redux';
@@ -34,6 +34,7 @@ import type {
   ViewFilter,
   ViewGroup,
   Entry,
+  Entries,
 } from '../types/redux';
 import type { EntryValue } from '../valueObjects/Entry';
 import type { Backend } from '../backend';
@@ -389,7 +390,8 @@ export function draftDuplicateEntry(entry: EntryMap) {
     type: DRAFT_CREATE_DUPLICATE_FROM_ENTRY,
     payload: createEntry(entry.get('collection'), '', '', {
       data: entry.get('data'),
-      i18n: entry.get('i18n'),
+      meta: entry.get('meta').toJS(),
+      i18n: entry.get('i18n').toJS(),
       mediaFiles: entry.get('mediaFiles').toJS(),
     }),
   };
@@ -1009,6 +1011,19 @@ function getPathError(
   };
 }
 
+function getExistingEntry(
+  entries: Entries,
+  collection: Collection,
+  path: string,
+  path_type: string,
+) {
+  const customPath = selectCustomPath(collection, fromJS({ entry: { meta: { path, path_type } } }));
+  if (!customPath) {
+    return undefined;
+  }
+  return selectEntryByPath(entries, collection.get('name'), customPath);
+}
+
 export function validateMetaField(
   state: State,
   collection: Collection,
@@ -1029,11 +1044,9 @@ export function validateMetaField(
       return getPathError(value, 'invalidPath', t);
     }
 
-    const customPath = selectCustomPath(collection, fromJS({ entry: { meta: { path: value } } }));
-    const existingEntry = customPath
-      ? selectEntryByPath(state.entries, collection.get('name'), customPath)
-      : undefined;
-
+    const existingEntry =
+      getExistingEntry(state.entries, collection, value, 'index') ??
+      getExistingEntry(state.entries, collection, value, 'slug');
     const existingEntryPath = existingEntry?.get('path');
     const draftPath = state.entryDraft?.getIn(['entry', 'path']);
 

packages/decap-cms-core/src/backend.ts

@@ -35,6 +35,8 @@ import {
   selectMediaFolders,
   selectFieldsComments,
   selectHasMetaPath,
+  isNestedSubfolders,
+  isNested,
 } from './reducers/collections';
 import { createEntry } from './valueObjects/Entry';
 import { sanitizeChar } from './lib/urlHelper';
@@ -297,14 +299,40 @@ type Implementation = BackendImplementation & {
   init: (config: CmsConfig, options: ImplementationInitOptions) => Implementation;
 };
 
-function prepareMetaPath(path: string, collection: Collection) {
+function prepareMetaPath(path: string, collection: Collection, slug?: string) {
   if (!selectHasMetaPath(collection)) {
     return path;
   }
+
+  if (
+    slug &&
+    isNested(collection) &&
+    !isNestedSubfolders(collection) &&
+    prepareMetaPathType(slug, collection) !== 'index'
+  ) {
+    return slug;
+  }
+
   const dir = dirname(path);
   return dir.slice(collection.get('folder')!.length + 1) || '/';
 }
 
+function isIndexFile(filePath: string, pattern: string, nested: boolean) {
+  const fileSlug = nested ? filePath?.split('/').pop() : filePath;
+  return fileSlug && new RegExp(pattern).test(fileSlug);
+}
+
+function prepareMetaPathType(slug: string, collection: Collection) {
+  const indexFileConfig = collection.get('index_file');
+  if (
+    indexFileConfig &&
+    isIndexFile(slug, indexFileConfig.get('pattern'), !!collection.get('nested'))
+  ) {
+    return 'index';
+  }
+  return 'slug';
+}
+
 function collectionDepth(collection: Collection) {
   let depth;
   depth =
@@ -517,7 +545,13 @@ export class Backend {
           label: loadedEntry.file.label,
           author: loadedEntry.file.author,
           updatedOn: loadedEntry.file.updatedOn,
-          meta: { path: prepareMetaPath(loadedEntry.file.path, collection) },
+          meta: {
+            path: prepareMetaPath(
+              loadedEntry.file.path,
+              collection,
+              selectEntrySlug(collection, loadedEntry.file.path),
+            ),
+          },
         },
       ),
     );
@@ -744,7 +778,7 @@ export class Backend {
           raw,
           label,
           mediaFiles,
-          meta: { path: prepareMetaPath(path, collection) },
+          meta: { path: prepareMetaPath(path, collection, slug) },
         }),
       );
     };
@@ -830,11 +864,16 @@ export class Backend {
 
     const getEntryValue = async (path: string) => {
       const loadedEntry = await this.implementation.getEntry(path);
-      let entry = createEntry(collection.get('name'), slug, loadedEntry.file.path, {
+      const entryPath = loadedEntry.file.path;
+
+      let entry = createEntry(collection.get('name'), slug, entryPath, {
         raw: loadedEntry.data,
         label,
         mediaFiles: [],
-        meta: { path: prepareMetaPath(loadedEntry.file.path, collection) },
+        meta: {
+          path: prepareMetaPath(entryPath, collection, slug),
+          path_type: prepareMetaPathType(slug, collection),
+        },
       });
 
       entry = this.entryWithFormat(collection)(entry);
@@ -928,7 +967,10 @@ export class Backend {
         updatedOn: entryData.updatedAt,
         author: entryData.pullRequestAuthor,
         status: entryData.status,
-        meta: { path: prepareMetaPath(path, collection) },
+        meta: {
+          path: prepareMetaPath(path, collection, slug),
+          path_type: prepareMetaPathType(slug, collection),
+        },
       });
 
       const entryWithFormat = this.entryWithFormat(collection)(entry);
@@ -961,6 +1003,9 @@ export class Backend {
       );
       entries = entries.filter(Boolean);
       const grouped = await groupEntries(collection, extension, entries as EntryValue[]);
+      if (grouped[0]?.srcSlug) {
+        grouped[0].slug = grouped[0].srcSlug;
+      }
       return grouped[0];
     } else {
       const entryWithFormat = await readAndFormatDataFile(dataFiles[0]);
@@ -1114,6 +1159,9 @@ export class Backend {
     const customPath = selectCustomPath(collection, entryDraft);
 
     let dataFile: DataFile;
+
+    let isFolder = true;
+
     if (newEntry) {
       if (!selectAllowNewEntries(collection)) {
         throw new Error('Not allowed to create new entries in this collection');
@@ -1125,6 +1173,7 @@ export class Backend {
         usedSlugs,
         customPath,
       );
+      isFolder = prepareMetaPathType(slug, collection) === 'index';
       const path = customPath || (selectEntryPath(collection, slug) as string);
       dataFile = {
         path,
@@ -1135,13 +1184,16 @@ export class Backend {
       updateAssetProxies(assetProxies, config, collection, entryDraft, path);
     } else {
       const slug = entryDraft.getIn(['entry', 'slug']);
+      isFolder = prepareMetaPathType(slug, collection) === 'index';
       const path = entryDraft.getIn(['entry', 'path']);
+
       dataFile = {
         path,
         // for workflow entries we refresh the slug on publish
         slug: customPath && !useWorkflow ? slugFromCustomPath(collection, customPath) : slug,
         raw: this.entryToRaw(collection, entryDraft.get('entry')),
         newPath: customPath === path ? undefined : customPath,
+        isFolder,
       };
     }
 
@@ -1158,6 +1210,7 @@ export class Backend {
         path,
         slug,
         newPath,
+        isFolder,
       );
     }