feat: Add updatedAt field in metadata

src/models.ts

@@ -19,6 +19,7 @@ export type NestedContributorsForPathFunction = (
 ) => void;
 export type UserByLoginFunction = (login: string) => Promise<Contributor | null>;
 export type CollectionOfPluginsFunction = (output: string, options: PluginOptions) => string;
+export type GetModifiedTimeByPathFunction = (filepath: string) => number | undefined;
 
 interface YfmConfig {
     varsPreset: VarsPreset;

src/services/contributors.ts

@@ -94,7 +94,10 @@ async function getContributorsForNestedFiles(
     return Object.assign({}, ...includesContributors);
 }
 
-function getRelativeIncludeFilePaths(fileData: FileData, includeContents: string[]): Set<string> {
+function getRelativeIncludeFilePaths(
+    fileData: Pick<FileData, 'tmpInputFilePath'>,
+    includeContents: string[],
+): Set<string> {
     const {tmpInputFilePath} = fileData;
     const relativeIncludeFilePaths: Set<string> = new Set();
 
@@ -115,4 +118,45 @@ function getRelativeIncludeFilePaths(fileData: FileData, includeContents: string
     return relativeIncludeFilePaths;
 }
 
-export {getFileContributorsMetadata, getFileContributorsString};
+async function getFileIncludes(
+    fileData: Pick<FileData, 'fileContent' | 'tmpInputFilePath' | 'inputFolderPathLength'>,
+) {
+    const {fileContent, tmpInputFilePath, inputFolderPathLength} = fileData;
+
+    const results = new Set<string>();
+
+    const includeContents = fileContent.match(REGEXP_INCLUDE_CONTENTS);
+    if (!includeContents || includeContents.length === 0) {
+        return [];
+    }
+    const relativeIncludeFilePaths: Set<string> = getRelativeIncludeFilePaths(
+        {tmpInputFilePath},
+        includeContents,
+    );
+    for (const relativeIncludeFilePath of relativeIncludeFilePaths.values()) {
+        const relativeFilePath = relativeIncludeFilePath.substring(inputFolderPathLength + 1);
+        if (results.has(relativeFilePath)) continue;
+        results.add(relativeFilePath);
+
+        let contentIncludeFile: string;
+        try {
+            contentIncludeFile = await readFile(relativeIncludeFilePath, 'utf8');
+        } catch (err) {
+            if (err.code === 'ENOENT') {
+                continue;
+            }
+            throw err;
+        }
+
+        const includedPaths = await getFileIncludes({
+            inputFolderPathLength,
+            fileContent: contentIncludeFile,
+            tmpInputFilePath: relativeIncludeFilePath,
+        });
+        includedPaths.forEach((path) => results.add(path));
+    }
+
+    return Array.from(results.values());
+}
+
+export {getFileContributorsMetadata, getFileContributorsString, getFileIncludes};

src/services/metadata.ts

@@ -7,12 +7,16 @@ import {
     updateAuthorMetadataStringByAuthorLogin,
     updateAuthorMetadataStringByFilePath,
 } from './authors';
-import {getFileContributorsMetadata, getFileContributorsString} from './contributors';
+import {
+    getFileContributorsMetadata,
+    getFileContributorsString,
+    getFileIncludes,
+} from './contributors';
 import {isObject} from './utils';
 import {сarriage} from '../utils';
 import {REGEXP_AUTHOR, metadataBorder} from '../constants';
 import {dirname, relative, resolve} from 'path';
-import {ArgvService} from './index';
+import {ArgvService, TocService} from './index';
 
 async function getContentWithUpdatedMetadata(
     fileContent: string,
@@ -105,6 +109,11 @@ async function getContentWithUpdatedDynamicMetadata(
             newMetadatas.push(contributorsMetaData);
         }
 
+        const mtimeMetadata = await getModifiedTimeMetadataString(options, fileContent);
+        if (mtimeMetadata) {
+            newMetadatas.push(mtimeMetadata);
+        }
+
         let authorMetadata = '';
         if (fileMetadata) {
             const matchAuthor = fileMetadata.match(REGEXP_AUTHOR);
@@ -188,6 +197,35 @@ async function getContributorsMetadataString(
     return undefined;
 }
 
+async function getModifiedTimeMetadataString(options: MetaDataOptions, fileContent: string) {
+    const {isContributorsEnabled, vcsConnector, fileData} = options;
+
+    const {tmpInputFilePath, inputFolderPathLength} = fileData;
+
+    const relativeFilePath = tmpInputFilePath.substring(inputFolderPathLength + 1);
+
+    if (isContributorsEnabled && vcsConnector) {
+        const includedFiles = await getFileIncludes({...fileData, fileContent});
+        includedFiles.push(relativeFilePath);
+
+        const tocCopyFileMap = TocService.getCopyFileMap();
+
+        const mtimeList = includedFiles
+            .map((path) => {
+                const mappedPath = tocCopyFileMap.get(path) || path;
+                return vcsConnector.getModifiedTimeByPath(mappedPath);
+            })
+            .filter((v) => typeof v === 'number') as number[];
+
+        const mtime = mtimeList.length ? Math.max(...mtimeList) : undefined;
+        if (mtime) {
+            return `updatedAt: ${new Date(mtime * 1000).toISOString()}`;
+        }
+    }
+
+    return undefined;
+}
+
 function getUpdatedMetadataString(newMetadatas: string[], defaultMetadata = ''): string {
     const newMetadata = newMetadatas.join(сarriage) + (newMetadatas.length ? сarriage : '');
     const preparedDefaultMetadata = defaultMetadata.trimRight();

src/services/tocs.ts

@@ -24,6 +24,7 @@ export interface TocServiceData {
 const storage: TocServiceData['storage'] = new Map();
 let navigationPaths: TocServiceData['navigationPaths'] = [];
 const includedTocPaths: TocServiceData['includedTocPaths'] = new Set();
+const tocFileCopyMap = new Map<string, string>();
 
 async function add(path: string) {
     const {
@@ -207,6 +208,10 @@ function _copyTocDir(tocPath: string, destDir: string) {
         } else {
             shell.cp(from, to);
         }
+
+        const relFrom = relative(inputFolderPath, from);
+        const relTo = relative(inputFolderPath, to);
+        tocFileCopyMap.set(relTo, relFrom);
     });
 }
 
@@ -396,11 +401,16 @@ function setNavigationPaths(paths: TocServiceData['navigationPaths']) {
     navigationPaths = paths;
 }
 
+function getCopyFileMap() {
+    return tocFileCopyMap;
+}
+
 export default {
     add,
     getForPath,
     getNavigationPaths,
     getTocDir,
     getIncludedTocPaths,
     setNavigationPaths,
+    getCopyFileMap,
 };

src/vcs-connector/connector-models.ts

@@ -2,6 +2,7 @@ import {
     Contributors,
     ContributorsByPathFunction,
     ExternalAuthorByPathFunction,
+    GetModifiedTimeByPathFunction,
     NestedContributorsForPathFunction,
     UserByLoginFunction,
 } from '../models';
@@ -31,6 +32,7 @@ export interface VCSConnector {
     addNestedContributorsForPath: NestedContributorsForPathFunction;
     getContributorsByPath: ContributorsByPathFunction;
     getUserByLogin: UserByLoginFunction;
+    getModifiedTimeByPath: GetModifiedTimeByPathFunction;
 }
 
 export interface VCSConnectorConfig {

src/vcs-connector/github.ts

@@ -33,9 +33,10 @@ const authorByPath: Map<string, Contributor | null> = new Map();
 const contributorsByPath: Map<string, FileContributors> = new Map();
 const contributorsData: Map<string, Contributor | null> = new Map();
 const loginUserMap: Map<string, Contributor | null> = new Map();
+const pathMTime = new Map<string, number>();
 
 async function getGitHubVCSConnector(): Promise<VCSConnector | undefined> {
-    const {contributors} = ArgvService.getConfig();
+    const {contributors, rootInput} = ArgvService.getConfig();
 
     const httpClientByToken = getHttpClientByToken();
     if (!httpClientByToken) {
@@ -49,6 +50,7 @@ async function getGitHubVCSConnector(): Promise<VCSConnector | undefined> {
         authorByPath.get(path) ?? null;
 
     if (contributors) {
+        await getFilesMTime(rootInput, pathMTime);
         await getAllContributorsTocFiles(httpClientByToken);
         addNestedContributorsForPath = (path: string, nestedContributors: Contributors) =>
             addNestedContributorsForPathFunction(path, nestedContributors);
@@ -60,6 +62,7 @@ async function getGitHubVCSConnector(): Promise<VCSConnector | undefined> {
         addNestedContributorsForPath,
         getContributorsByPath,
         getUserByLogin: (login: string) => getUserByLogin(httpClientByToken, login),
+        getModifiedTimeByPath: (filename: string) => pathMTime.get(filename),
     };
 }
 
@@ -364,4 +367,45 @@ function shouldAuthorBeIgnored({email, name}: ShouldAuthorBeIgnoredArgs) {
     return false;
 }
 
+async function getFilesMTime(repoDir: string, pathMTime: Map<string, number>) {
+    const timeFiles = await simpleGit({
+        baseDir: repoDir,
+    }).raw(
+        'log',
+        '--reverse',
+        '--before=now',
+        '--diff-filter=ADMR',
+        '--pretty=format:%ct',
+        '--name-status',
+    );
+
+    const parts = timeFiles.split(/\n\n/);
+    while (parts.length) {
+        const part = parts.shift();
+        if (!part) return;
+        const lines = part.trim().split(/\n/);
+        const committerDate = lines.shift();
+        const unixtime = Number(committerDate);
+        for (let i = 0, len = lines.length; i < len; i++) {
+            const line = lines[i];
+            const [status, from, to] = line.split(/\t/);
+            switch (status[0]) {
+                case 'R': {
+                    pathMTime.delete(from);
+                    pathMTime.set(to, unixtime);
+                    break;
+                }
+                case 'D': {
+                    pathMTime.delete(from);
+                    break;
+                }
+                default: {
+                    pathMTime.set(from, unixtime);
+                }
+            }
+        }
+    }
+    return pathMTime;
+}
+
 export default getGitHubVCSConnector;

tests/integrations/services/metadataAuthors.test.ts

@@ -11,6 +11,7 @@ const simpleMetadataFilePath = 'mocks/fileContent/metadata/simpleMetadata.md';
 
 jest.mock('services/contributors', () => ({
     getFileContributorsMetadata: () => Promise.resolve(''),
+    getFileIncludes: () => Promise.resolve([]),
 }));
 
 describe('getContentWithUpdatedMetadata (Authors)', () => {
@@ -27,6 +28,7 @@ describe('getContentWithUpdatedMetadata (Authors)', () => {
         getContributorsByPath: () => Promise.resolve(null),
         getUserByLogin: () => Promise.resolve(expectedAuthorData),
         getExternalAuthorByPath: () => expectedAuthorData,
+        getModifiedTimeByPath: () => undefined,
     };
 
     describe('should return file content with updated author in metadata', () => {

tests/integrations/services/metadataContributors.test.ts

@@ -26,6 +26,7 @@ describe('getContentWithUpdatedMetadata (Contributors)', () => {
         getContributorsByPath: () => Promise.resolve(null),
         getUserByLogin: () => Promise.resolve(null),
         getExternalAuthorByPath: () => null,
+        getModifiedTimeByPath: () => undefined,
     };
 
     describe('should return file content with updated contributors in metadata ' +

tests/units/services/authors.test.ts

@@ -20,10 +20,11 @@ const author = {
 const authorByPath: Map<string, Contributor | null> = new Map();
 
 const defaultVCSConnector: VCSConnector = {
-    addNestedContributorsForPath: () => {},
+    addNestedContributorsForPath: () => { },
     getContributorsByPath: () => Promise.resolve(null),
     getUserByLogin: () => Promise.resolve(author),
     getExternalAuthorByPath: (path) => authorByPath.get(path),
+    getModifiedTimeByPath: () => undefined,
 };
 
 describe('getAuthorDetails returns author details', () => {

tests/units/services/metadata.test.ts

@@ -25,6 +25,7 @@ const contributorsString: string = replaceDoubleToSingleQuotes(JSON.stringify(co
 
 jest.mock('services/contributors', () => ({
     getFileContributorsString: () => Promise.resolve(contributorsString),
+    getFileIncludes: () => Promise.resolve([]),
 }));
 
 const authorString: string = replaceDoubleToSingleQuotes(JSON.stringify(contributorSecond));
@@ -38,6 +39,7 @@ const defaultVCSConnector: VCSConnector = {
     getContributorsByPath: () => Promise.resolve(null),
     getUserByLogin: () => Promise.resolve(null),
     getExternalAuthorByPath: () => null,
+    getModifiedTimeByPath: () => undefined,
 };
 
 describe('getUpdatedMetadata', () => {