@eventcatalog/core 2.8.12 → 2.9.0

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @eventcatalog/core
 
+## 2.9.0
+
+### Minor Changes
+
+- 70d27a7: feat(core): support nested folder structures for domains, services and messages
+
 ## 2.8.12
 
 ### Patch Changes

package/package.json

@@ -6,7 +6,7 @@
     "url": "https://github.com/event-catalog/eventcatalog.git"
   },
   "type": "module",
-  "version": "2.8.12",
+  "version": "2.9.0",
   "publishConfig": {
     "access": "public"
   },

package/scripts/catalog-to-astro-content-directory.js

@@ -3,277 +3,100 @@ import * as path from 'node:path';
 import fs from 'fs';
 import { fileURLToPath } from 'url';
 import os from 'node:os';
-import { verifyRequiredFieldsAreInCatalogConfigFile } from './eventcatalog-config-file-utils.js';
+import { verifyRequiredFieldsAreInCatalogConfigFile, addPropertyToFrontMatter } from './eventcatalog-config-file-utils.js';
+import { mapCatalogToAstro } from './map-catalog-to-astro.js';
 
 const __filename = fileURLToPath(import.meta.url);
 const scriptsDir = path.dirname(__filename);
 
-const getTargetPath = (source, target, type, file) => {
-  const relativePath = path.relative(source, file);
-  const cleanedRelativePath = relativePath.split(type);
-  const targetForEvents = path.join(type, cleanedRelativePath[1]);
-  return path.join(target, targetForEvents);
-};
-
-const ensureDirSync = async (filePath) => {
-  const dir = path.dirname(filePath);
-
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-};
-
-const copyFiles = async ({ source, target, catalogFilesDir, pathToMarkdownFiles, pathToAllFiles, type, ignore = null }) => {
-  // Find all the event files
-  const markdownFiles = await glob(pathToMarkdownFiles, {
-    nodir: true,
-    windowsPathsNoEscape: os.platform() == 'win32',
-    ignore: ignore,
-  });
-  const files = await glob(pathToAllFiles, {
-    ignore: {
-      ignored: (p) => /\.md$/.test(p.name),
-    },
+const copyFiles = async (source, target) => {
+  const files = await glob(path.join(source, '**'), {
     nodir: true,
     windowsPathsNoEscape: os.platform() == 'win32',
   });
 
-  const publicDir = path.join(target, '../../public/generated');
-
-  // Copy markdown files into the astro content (collection) folder
-  for (const file of markdownFiles) {
-    let fileTarget = target;
-
-    // If they are change logs they need to go into their own content folder
-    if (file.includes('changelog.md')) {
-      fileTarget = path.join(target, 'changelogs');
-    }
-
-    const targetPath = getTargetPath(source, fileTarget, type, file);
-
-    //ensure the directory exists
-    ensureDirSync(path.dirname(targetPath));
-
-    fs.cpSync(file, targetPath.replace('index.md', 'index.mdx').replace('changelog.md', 'changelog.mdx'));
-  }
-
-  // Copy all other files (non markdown) files into catalog-files directory (non collection)
   for (const file of files) {
-    // Ignore any md files
-    if (file.endsWith('.md')) {
-      continue;
-    }
-
-    const relativePath = path.relative(source, file);
-    const cleanedRelativePath = relativePath.split(type);
-    if (!cleanedRelativePath[1]) continue;
-    const targetForEvents = path.join(type, cleanedRelativePath[1]);
-
-    // Catalog-files-directory
-    const targetPath = path.join(catalogFilesDir, targetForEvents);
-    if (!fs.existsSync(path.dirname(targetPath))) {
-      fs.mkdirSync(path.dirname(targetPath), { recursive: true });
-    }
-    await fs.cpSync(file, targetPath);
+    mapCatalogToAstro({
+      filePath: file,
+      astroDir: target,
+      projectDir: source,
+    })
+      .map((astroPath) => {
+        fs.cpSync(file, astroPath);
+        return { oldPath: file, newPath: astroPath };
+      })
+      .map(({ oldPath, newPath }) => {
+        if (!oldPath.endsWith('.md') && !oldPath.endsWith('.mdx')) return;
+        try {
+          // EventCatalog requires the original path to be in the frontmatter for Schemas and Changelogs
+          const content = fs.readFileSync(newPath, 'utf-8');
+          const frontmatter = addPropertyToFrontMatter(content, 'pathToFile', oldPath);
+          fs.writeFileSync(newPath, frontmatter);
+        } catch (error) {
+          // silent fail
+        }
+      });
+  }
+};
 
-    // // // Public Directory
-    const publicTargetPath = path.join(publicDir, targetForEvents);
+const ensureAstroCollectionNotEmpty = async (astroDir) => {
+  // TODO: maybe import collections from `src/content/config.ts`...
+  const COLLECTIONS = ['events', 'commands', 'services', 'users', 'teams', 'domains', 'flows', 'pages', 'changelogs'];
 
-    if (!fs.existsSync(path.dirname(publicTargetPath))) {
-      fs.mkdirSync(path.dirname(publicTargetPath), { recursive: true });
-    }
+  // Check empty collections
+  const emptyCollections = [];
+  for (const collection of COLLECTIONS) {
+    const markdownFiles = await glob(path.join(astroDir, 'src/content/', collection, '**'), {
+      nodir: true,
+      windowsPathsNoEscape: os.platform() == 'win32',
+    });
 
-    await fs.cpSync(file, publicTargetPath);
+    if (markdownFiles.length === 0) emptyCollections.push(collection);
   }
 
-  // Check if the directory is empty. EC (astro collections) requires at least 1 item in the collection
-  // insert empty one that is filtered out
-  if (markdownFiles.length === 0) {
-    const defaultCollectionFilesDir = path.join(scriptsDir, 'default-files-for-collections');
-    const defaultFile = path.join(defaultCollectionFilesDir, `${type}.md`);
-    const targetDir = path.join(target, type);
+  // Hydrate empty collections
+  const defaultCollectionFilesDir = path.join(scriptsDir, 'default-files-for-collections');
+  for (const collection of emptyCollections) {
+    const defaultFile = path.join(defaultCollectionFilesDir, `${collection}.md`);
+    const targetDir = path.join(astroDir, 'src/content/', collection);
     if (!fs.existsSync(targetDir)) {
       fs.mkdirSync(targetDir, { recursive: true });
     }
-    await fs.cpSync(defaultFile, path.join(targetDir, `${type}.md`));
+    fs.cpSync(defaultFile, path.join(targetDir, `${collection}.md`));
   }
 };
 
-const copyComponents = async ({ source, target }) => {
-  const componentsDir = path.join(source, 'components');
-  const componentsTarget = path.join(target, '../custom-defined-components');
-
-  // Clear the component directory before we copy files over
-  if (fs.existsSync(componentsTarget)) {
-    await fs.rmSync(componentsTarget, { recursive: true });
-  }
-
-  if (!fs.existsSync(componentsDir) || !fs.statSync(componentsDir).isDirectory()) {
-    return;
-  }
+export const catalogToAstro = async (source, astroDir) => {
+  const astroContentDir = path.join(astroDir, 'src/content/');
 
-  // Copy files
-  await fs.cpSync(componentsDir, componentsTarget, { recursive: true });
-};
+  console.log(path.join(astroContentDir, 'config.ts'));
 
-export const catalogToAstro = async (source, astroContentDir, catalogFilesDir) => {
   // Config file
   const astroConfigFile = fs.readFileSync(path.join(astroContentDir, 'config.ts'));
 
   // Clear the astro directory before we copy files over
-  await fs.rmSync(astroContentDir, { recursive: true });
+  fs.rmSync(astroContentDir, { recursive: true });
 
   // Create the folder again
   fs.mkdirSync(astroContentDir);
 
   // Write config file back
-  // ensureDirSync(astroContentDir);
   fs.writeFileSync(path.join(astroContentDir, 'config.ts'), astroConfigFile);
 
-  // Copy the public directory files into the astro public directory
-  const usersPublicDirectory = path.join(source, 'public');
-  const astroPublicDir = path.join(astroContentDir, '../../public');
-
-  if (fs.existsSync(usersPublicDirectory)) {
-    // fs.mkdirSync(astroPublicDir, { recursive: true });
-    fs.cpSync(usersPublicDirectory, astroPublicDir, { recursive: true });
-  }
-
-  // Copy all the event files over
-  await copyFiles({
-    source,
-    target: astroContentDir,
-    catalogFilesDir,
-    pathToMarkdownFiles: [
-      path.join(source, 'events/**/**/index.md'),
-      path.join(source, 'services/**/events/**/index.md'),
-      path.join(source, 'domains/**/events/**/index.md'),
-      path.join(source, 'events/**/**/changelog.md'),
-    ],
-    pathToAllFiles: [
-      path.join(source, 'events/**'),
-      path.join(source, 'services/**/events/**'),
-      path.join(source, 'domains/**/events/**'),
-    ],
-    type: 'events',
-  });
-
-  // // copy commands
-  await copyFiles({
-    source,
-    target: astroContentDir,
-    catalogFilesDir,
-    pathToMarkdownFiles: [
-      path.join(source, 'commands/**/**/index.md'),
-      path.join(source, 'services/**/commands/**/index.md'),
-      path.join(source, 'domains/**/commands/**/index.md'),
-      path.join(source, 'commands/**/**/changelog.md'),
-    ],
-    pathToAllFiles: [
-      path.join(source, 'commands/**'),
-      path.join(source, 'services/**/commands/**'),
-      path.join(source, 'domains/**/commands/**'),
-    ],
-    type: 'commands',
-  });
-
-  // // Copy all the service files over
-  await copyFiles({
-    source,
-    target: astroContentDir,
-    catalogFilesDir,
-    pathToMarkdownFiles: [
-      path.join(source, 'services/**/**/index.md'),
-      path.join(source, 'domains/**/services/**/index.md'),
-      path.join(source, 'services/**/**/changelog.md'),
-    ],
-    pathToAllFiles: [path.join(source, 'services/**'), path.join(source, 'domains/**/services/**')],
-    ignore: [
-      path.join(source, 'services/**/events/**'),
-      path.join(source, 'services/**/commands/**'),
-      path.join(source, 'services/**/flows/**'),
-    ],
-    type: 'services',
-  });
-
-  // // Copy all the domain files over
-  await copyFiles({
-    source,
-    target: astroContentDir,
-    catalogFilesDir,
-    pathToMarkdownFiles: [path.join(source, 'domains/**/**/index.md'), path.join(source, 'domains/**/**/changelog.md')],
-    pathToAllFiles: [path.join(source, 'domains/**')],
-    ignore: [
-      path.join(source, 'domains/**/services/**'),
-      path.join(source, 'domains/**/commands/**'),
-      path.join(source, 'domains/**/events/**'),
-      path.join(source, 'domains/**/flows/**'),
-    ],
-    type: 'domains',
-  });
-
-  // // Copy all the flow files over
-  await copyFiles({
-    source,
-    target: astroContentDir,
-    catalogFilesDir,
-    pathToMarkdownFiles: [
-      path.join(source, 'flows/**/**/index.md'),
-      path.join(source, 'flows/**/**/changelog.md'),
-      path.join(source, 'services/**/flows/**/index.md'),
-      path.join(source, 'domains/**/flows/**/index.md'),
-    ],
-    pathToAllFiles: [
-      path.join(source, 'flows/**'),
-      path.join(source, 'services/**/flows/**'),
-      path.join(source, 'domains/**/flows/**'),
-    ],
-    type: 'flows',
-  });
-
-  // // Copy all the users
-  await copyFiles({
-    source,
-    target: astroContentDir,
-    catalogFilesDir,
-    pathToMarkdownFiles: [path.join(source, 'users/**/*.md')],
-    pathToAllFiles: [],
-    type: 'users',
-  });
-
-  // // Copy all the teams
-  await copyFiles({
-    source,
-    target: astroContentDir,
-    catalogFilesDir,
-    pathToMarkdownFiles: [path.join(source, 'teams/**/*.md')],
-    pathToAllFiles: [],
-    type: 'teams',
-  });
-
-  // // Copy all the pages (optional)
-  await copyFiles({
-    source,
-    target: astroContentDir,
-    catalogFilesDir,
-    pathToMarkdownFiles: [path.join(source, 'pages/**/*.md')],
-    pathToAllFiles: [],
-    type: 'pages',
-  });
-
-  // Copy the components if they are defined
-  await copyComponents({ source, target: astroContentDir, catalogFilesDir });
-
   // Verify required fields are in the catalog config file
   await verifyRequiredFieldsAreInCatalogConfigFile(source);
+
+  await copyFiles(source, astroDir);
+
+  // Check if the directory is empty. EC (astro collections) requires at least 1 item in the collection
+  // insert empty one that is filtered out
+  await ensureAstroCollectionNotEmpty(astroDir);
 };
 
 if (process.env.NODE_ENV !== 'test') {
   // // Get the project directory of the source
   const source = process.env.PROJECT_DIR;
+  const astroDir = process.env.CATALOG_DIR;
 
-  const astroContentDir = path.join(process.env.CATALOG_DIR, 'src/content');
-  const catalogFilesDir = path.join(process.env.CATALOG_DIR, 'src/catalog-files');
-
-  catalogToAstro(source, astroContentDir, catalogFilesDir);
+  catalogToAstro(source, astroDir);
 }

package/scripts/eventcatalog-config-file-utils.js

@@ -80,3 +80,21 @@ export const verifyRequiredFieldsAreInCatalogConfigFile = async (projectDirector
     // fail silently, it's overly important
   }
 };
+
+export function addPropertyToFrontMatter(input, newProperty, newValue) {
+  // Split the input into front matter and content
+  const [_, frontMatter, content] = input.split('---');
+
+  // Parse the front matter
+  const frontMatterLines = frontMatter.trim().split('\n');
+  const updatedFrontMatterLines = [...frontMatterLines];
+
+  // Add the new property
+  updatedFrontMatterLines.push(`${newProperty}: ${newValue}`);
+
+  // Reconstruct the updated input
+  const updatedFrontMatter = updatedFrontMatterLines.join('\n');
+  const updatedInput = `---\n${updatedFrontMatter}\n---\n${content.trim()}`;
+
+  return updatedInput;
+}

package/scripts/map-catalog-to-astro.js

@@ -0,0 +1,162 @@
+import path from 'node:path';
+
+const COLLECTION_KEYS = ['events', 'commands', 'services', 'users', 'teams', 'domains', 'flows', 'pages', 'changelogs'];
+
+/**
+ * @typedef {Object} MapCatalogToAstroParams
+ * @prop {string} filePath The catalog file path
+ * @prop {string} astroDir The astro directory
+ * @prop {string} projectDir The user's project directory
+ */
+
+/**
+ *
+ * @param {MapCatalogToAstroParams} params
+ * @returns {string[]} The astro file paths
+ */
+export function mapCatalogToAstro({ filePath, astroDir, projectDir }) {
+  const relativeFilePath = removeBasePath(filePath, projectDir);
+
+  if (!isCatalogRelated(relativeFilePath)) {
+    return [];
+  }
+
+  const baseTargetPaths = getBaseTargetPaths(relativeFilePath);
+  const relativeTargetPath = getRelativeTargetPath(relativeFilePath);
+
+  return baseTargetPaths.map((base) =>
+    path.join(astroDir, base, relativeTargetPath.replace('index.md', 'index.mdx').replace('changelog.md', 'changelog.mdx'))
+  );
+}
+
+/**
+ *
+ * @param {string} fullPath
+ * @param {string} basePath
+ * @returns {string} The fullPath without the basePath
+ */
+function removeBasePath(fullPath, basePath) {
+  const relativePath = path.relative(basePath, fullPath);
+  return relativePath.startsWith('..') ? fullPath : relativePath;
+}
+
+/**
+ * Check if the key is an ASTRO COLLECTION KEY
+ * @param {string} key
+ * @returns {boolean}
+ */
+function isCollectionKey(key) {
+  return COLLECTION_KEYS.includes(key);
+}
+
+/**
+ * Checks whether the given path is a configuration file, styles file, public asset file or collection file.
+ * @param {string} filePath - The file path without the projectDir prefix.
+ * @returns {boolean}
+ */
+function isCatalogRelated(filePath) {
+  const filePathArr = filePath.split(path.sep).filter(Boolean);
+
+  if (
+    [
+      'eventcatalog.config.js', // config file at root
+      'eventcatalog.styles.css', // custom styles file at root
+      'components', // custom components
+      'public', // public assets
+      ...COLLECTION_KEYS,
+    ].includes(filePathArr[0])
+  ) {
+    return true;
+  }
+
+  return false;
+}
+
+/**
+ * Generates the base target path accordingly to the file path.
+ * @param {string} filePath The path to the file without PROJECT_DIR prefix.
+ * @returns {Array.<'src/content'|'public/generated'|'src/catalog-files'|'/'>} The base target path.
+ */
+function getBaseTargetPaths(filePath) {
+  const filePathArr = filePath.split(path.sep).filter(Boolean);
+
+  // Collection
+  if (isCollectionKey(filePathArr[0])) {
+    // Changelogs files
+    if (filePathArr[filePathArr.length - 1] == 'changelog.md') {
+      return [path.join('src', 'content', 'changelogs')];
+    }
+
+    // Markdown files
+    if (filePathArr[filePathArr.length - 1].match(/\.md$/)) {
+      return [path.join('src', 'content')];
+    }
+
+    // This is a workaround to differentiate between a file and a directory.
+    // Of course this is not the best solution. But how differentiate? `fs.stats`
+    // could be used, but sometimes the filePath references a deleted file/directory
+    // which causes an error when using `fs.stats`.
+    const hasExtension = (str) => /\.[a-zA-Z0-9]{2,}$/.test(str);
+
+    // Assets files
+    if (hasExtension(filePath)) {
+      return [path.join('public', 'generated'), path.join('src', 'catalog-files')];
+    }
+
+    /**
+     * @parcel/watcher throttle and coalesce events for performance reasons.
+     *
+     * Consider the following:
+     *    The user deletes a large `services/` dir from eventcatalog.
+     *    The @parcel/watcher could emit only one delete event of the
+     *    `services/` directory.
+     *
+     * In this situation we need delete all files from
+     * - `public/generated/services/`
+     * - `src/catalog-files/services/`
+     * - `src/content/services/`
+     *
+     * TODO: What happens if services contains commands/events inside of it??? How handle this?
+     */
+    // Directories
+    return [path.join('public', 'generated'), path.join('src', 'catalog-files'), path.join('src', 'content')];
+  }
+
+  // Custom components
+  if (filePathArr[0] == 'components') {
+    return [path.join('src', 'custom-defined-components')];
+  }
+
+  // Public assets (public/*)
+  if (filePathArr[0] == 'public') {
+    return [path.join('public')];
+  }
+
+  /**
+   * Config files:
+   * - eventcatalog.config.js
+   * - eventcatalog.styles.css
+   */
+  return [path.join('/')];
+}
+
+/**
+ * Generates the path until the ASTRO_COLLECTION_KEY or the PROJECT_DIR root.
+ * @param {string} filePath The path to the file.
+ * @returns {string} The path until the COLLECTION_KEY or PROJECT_DIR root.
+ */
+function getRelativeTargetPath(filePath) {
+  const filePathArr = filePath.split(path.sep).filter(Boolean);
+
+  if (filePathArr[0] == 'public' || filePathArr[0] == 'components') {
+    filePathArr.shift();
+  }
+
+  const relativePath = [];
+  for (let i = filePathArr.length - 1; i >= 0; i--) {
+    relativePath.unshift(filePathArr[i]);
+    if (isCollectionKey(filePathArr[i])) break;
+  }
+
+  return path.join(...relativePath);
+}

package/scripts/watcher.js

@@ -1,69 +1,134 @@
-#!/usr/bin/env node
 import watcher from '@parcel/watcher';
-import path from 'path';
-import fs from 'fs';
-import os from 'os';
+import fs from 'node:fs';
+import path from 'node:path';
+import { mapCatalogToAstro } from './map-catalog-to-astro.js';
+import { rimrafSync } from 'rimraf';
+import { addPropertyToFrontMatter } from './eventcatalog-config-file-utils.js';
 
-// Where the users project is located
-const projectDirectory = process.env.PROJECT_DIR || process.cwd();
-// Where the catalog code is located.
-const catalogDirectory = process.env.CATALOG_DIR;
+/**
+ * @typedef {Object} Event
+ * @property {string} path
+ * @property {"create"|"update"|"delete"} type
+ *
+ * @typedef {(err: Error | null, events: Event[]) => unknown} SubscribeCallback
+ */
 
-const contentPath = path.join(catalogDirectory, 'src', 'content');
+/**
+ *
+ * @param {string} projectDirectory
+ * @param {string} catalogDirectory
+ * @param {SubscribeCallback|undefined} callback
+ */
+export async function watch(projectDirectory, catalogDirectory, callback = undefined) {
+  const subscription = await watcher.subscribe(
+    projectDirectory,
+    compose(
+      /**
+       * @param {Error|null} err
+       * @param {Event[]} events
+       * @returns {unknown}
+       */
+      (err, events) => {
+        if (err) {
+          return;
+        }
 
-const watchList = ['domains', 'commands', 'events', 'services', 'teams', 'users', 'pages', 'components', 'flows'];
-// const absoluteWatchList = watchList.map((item) => path.join(projectDirectory, item));
+        for (let event of events) {
+          const { path: filePath, type } = event;
 
-// confirm folders exist before watching them
-const verifiedWatchList = watchList.filter((item) => fs.existsSync(path.join(projectDirectory, item)));
+          const astroPaths = mapCatalogToAstro({
+            filePath,
+            astroDir: catalogDirectory,
+            projectDir: projectDirectory,
+          });
 
-const extensionReplacer = (collection, file) => {
-  if (collection === 'teams' || collection == 'users') return file;
-  return file.replace('.md', '.mdx');
-};
+          for (const astroPath of astroPaths) {
+            switch (type) {
+              case 'create':
+              case 'update':
+                try {
+                  // EventCatalog requires the original path to be in the frontmatter for Schemas and Changelogs
+                  if (astroPath.endsWith('.mdx')) {
+                    const content = fs.readFileSync(astroPath, 'utf-8');
+                    const frontmatter = addPropertyToFrontMatter(content, 'pathToFile', filePath);
+                    fs.writeFileSync(astroPath, frontmatter);
+                  }
+                } catch (error) {
+                  // silent fail
+                }
 
-for (let item of [...verifiedWatchList]) {
-  // Listen to the users directory for any changes.
-  watcher.subscribe(path.join(projectDirectory, item), (err, events) => {
-    if (err) {
-      return;
-    }
-    for (let event of events) {
-      const { path: eventPath, type } = event;
-      const file = eventPath.split(item)[1];
-      let newPath = path.join(contentPath, item, extensionReplacer(item, file));
+                if (fs.statSync(filePath).isDirectory()) fs.mkdirSync(astroPath, { recursive: true });
+                else retryEPERM(fs.cpSync)(filePath, astroPath);
 
-      // Check if changlogs, they need to go into their own content folder
-      if (file.includes('changelog.md')) {
-        newPath = newPath.replace('src/content', 'src/content/changelogs');
-        if (os.platform() == 'win32') {
-          newPath = newPath.replace('src\\content', 'src\\content\\changelogs');
+                break;
+              case 'delete':
+                retryEPERM(rimrafSync)(astroPath);
+                break;
+            }
+          }
         }
-      }
+      },
+      callback
+    ),
+    {
+      ignore: [`**/${catalogDirectory}/!(${projectDirectory})**`],
+    }
+  );
 
-      // Check if its a component, need to move to the correct location
-      if (newPath.includes('components')) {
-        newPath = newPath.replace('src/content/components', 'src/custom-defined-components');
-        if (os.platform() == 'win32') {
-          newPath = newPath.replace('src\\content\\components', 'src\\custom-defined-components');
-        }
-      }
+  return () => subscription.unsubscribe();
+}
 
-      // If config files have changes
-      if (eventPath.includes('eventcatalog.config.js') || eventPath.includes('eventcatalog.styles.css')) {
-        fs.cpSync(eventPath, path.join(catalogDirectory, file));
-        return;
+/**
+ *
+ * @param  {...Function} fns
+ * @returns {SubscribeCallback}
+ */
+function compose(...fns) {
+  return function (err, events) {
+    fns.filter(Boolean).forEach((fn, i) => {
+      try {
+        fn(err, events);
+      } catch (error) {
+        console.error({ error });
+        throw error;
       }
+    });
+  };
+}
 
-      // If markdown files or astro files copy file over to the required location
-      if ((eventPath.endsWith('.md') || eventPath.endsWith('.astro')) && type === 'update') {
-        fs.cpSync(eventPath, newPath);
-      }
+const MAX_RETRIES = 5;
+const DELAY_MS = 100;
 
-      // IF directory remove it
-      if (type === 'delete') {
-        fs.rmSync(newPath);
+// In win32 some tests failed when attempting copy the file at the same time
+// that another process is editing it.
+function retryEPERM(fn) {
+  return (...args) => {
+    let retries = 0;
+
+    while (retries < MAX_RETRIES) {
+      try {
+        return fn(...args);
+      } catch (err) {
+        if (err.code !== 'EPERM') throw err;
+        setTimeout(() => {}, DELAY_MS);
+        retries += 1;
       }
     }
-  });
+  };
+}
+
+/**
+ * TODO: call `watch` from the dev command.
+ * Calling `watch` there will avoid these if statement.
+ * The same could be done to `catalog-to-astro-content-directory`
+ */
+if (process.env.NODE_ENV !== 'test') {
+  // Where the users project is located
+  const projectDirectory = process.env.PROJECT_DIR || process.cwd();
+  // Where the catalog code is located.
+  const catalogDirectory = process.env.CATALOG_DIR || path.join(projectDirectory, '.eventcatalog-core');
+
+  const unsub = await watch(projectDirectory, catalogDirectory);
+
+  process.on('exit', () => unsub());
 }

package/src/content/config.ts

@@ -61,10 +61,12 @@ const baseSchema = z.object({
   // Used by eventcatalog
   versions: z.array(z.string()).optional(),
   latestVersion: z.string().optional(),
+  pathToFile: z.string().optional(),
   catalog: z
     .object({
       path: z.string(),
       filePath: z.string(),
+      astroContentFilePath: z.string(),
       publicPath: z.string(),
       type: z.string(),
     })

package/src/utils/collections/file-diffs.ts

@@ -50,7 +50,7 @@ export async function getFilesForDiffInCollection(
   collection: CollectionEntry<CollectionTypes>
 ): Promise<Array<{ file: string; dir: string }>> {
   // @ts-ignore
-  const pathToFolder = collection.catalog?.absoluteFilePath;
+  const pathToFolder = collection.data.pathToFile;
   if (!pathToFolder) return [];
 
   const dir = dirname(pathToFolder);