@eventcatalog/sdk 2.2.6 → 2.2.8

package/dist/eventcatalog.mjs

@@ -13,7 +13,7 @@ import { join as join3 } from "node:path";
 import { globSync } from "glob";
 import fsSync from "node:fs";
 import { copy } from "fs-extra";
-import { join } from "node:path";
+import { join, dirname } from "node:path";
 import matter from "gray-matter";
 import { satisfies, validRange, valid } from "semver";
 var versionExists = async (catalogDir, id, version) => {
@@ -48,7 +48,8 @@ var findFileById = async (catalogDir, id, version) => {
 var getFiles = async (pattern, ignore = "") => {
   try {
     const ignoreList = Array.isArray(ignore) ? ignore : [ignore];
-    const files = globSync(pattern, { ignore: ["node_modules/**", ...ignoreList] });
+    const baseDir = pattern.includes("**") ? pattern.split("**")[0] : dirname(pattern);
+    const files = globSync(pattern, { cwd: baseDir, ignore: ["node_modules/**", ...ignoreList] });
     return files;
   } catch (error) {
     throw new Error(`Error finding files: ${error}`);
@@ -100,7 +101,7 @@ var uniqueVersions = (messages) => {
 };
 
 // src/internal/resources.ts
-import { dirname, join as join2 } from "path";
+import { dirname as dirname2, join as join2 } from "path";
 import matter2 from "gray-matter";
 import fs from "node:fs/promises";
 import fsSync2 from "node:fs";
@@ -113,7 +114,7 @@ var versionResource = async (catalogDir, id) => {
     throw new Error(`No resource found with id: ${id}`);
   }
   const file = matchedFiles[0];
-  const sourceDirectory = dirname(file);
+  const sourceDirectory = dirname2(file);
   const { data: { version = "0.0.1" } = {} } = matter2.read(file);
   const targetDirectory = getVersionedDirectory(sourceDirectory, version);
   fsSync2.mkdirSync(targetDirectory, { recursive: true });
@@ -134,12 +135,14 @@ var writeResource = async (catalogDir, resource, options = {
   path: "",
   type: "",
   override: false,
-  versionExistingContent: false
+  versionExistingContent: false,
+  format: "mdx"
 }) => {
   const path4 = options.path || `/${resource.id}`;
   const fullPath = join2(catalogDir, path4);
+  const format = options.format || "mdx";
   fsSync2.mkdirSync(fullPath, { recursive: true });
-  const lockPath = join2(fullPath, "index.mdx");
+  const lockPath = join2(fullPath, `index.${format}`);
   if (!fsSync2.existsSync(lockPath)) {
     fsSync2.writeFileSync(lockPath, "");
   }
@@ -186,7 +189,7 @@ var getResourcePath = async (catalogDir, id, version) => {
   return {
     fullPath: file,
     relativePath: file.replace(catalogDir, ""),
-    directory: dirname(file.replace(catalogDir, ""))
+    directory: dirname2(file.replace(catalogDir, ""))
   };
 };
 var getResources = async (catalogDir, {
@@ -222,7 +225,7 @@ var rmResourceById = async (catalogDir, id, version, options) => {
   } else {
     await Promise.all(
       matchedFiles.map(async (file) => {
-        const directory = dirname(file);
+        const directory = dirname2(file);
         await fs.rm(directory, { recursive: true, force: true });
       })
     );
@@ -231,14 +234,14 @@ var rmResourceById = async (catalogDir, id, version, options) => {
 var addFileToResource = async (catalogDir, id, file, version) => {
   const pathToResource = await findFileById(catalogDir, id, version);
   if (!pathToResource) throw new Error("Cannot find directory to write file to");
-  fsSync2.writeFileSync(join2(dirname(pathToResource), file.fileName), file.content);
+  fsSync2.writeFileSync(join2(dirname2(pathToResource), file.fileName), file.content);
 };
 var getFileFromResource = async (catalogDir, id, file, version) => {
   const pathToResource = await findFileById(catalogDir, id, version);
   if (!pathToResource) throw new Error("Cannot find directory of resource");
-  const exists = await fs.access(join2(dirname(pathToResource), file.fileName)).then(() => true).catch(() => false);
+  const exists = await fs.access(join2(dirname2(pathToResource), file.fileName)).then(() => true).catch(() => false);
   if (!exists) throw new Error(`File ${file.fileName} does not exist in resource ${id} v(${version})`);
-  return fsSync2.readFileSync(join2(dirname(pathToResource), file.fileName), "utf-8");
+  return fsSync2.readFileSync(join2(dirname2(pathToResource), file.fileName), "utf-8");
 };
 var getVersionedDirectory = (sourceDirectory, version) => {
   return join2(sourceDirectory, "versioned", version);
@@ -247,8 +250,12 @@ var getVersionedDirectory = (sourceDirectory, version) => {
 // src/events.ts
 var getEvent = (directory) => async (id, version) => getResource(directory, id, version, { type: "event" });
 var getEvents = (directory) => async (options) => getResources(directory, { type: "events", ...options });
-var writeEvent = (directory) => async (event, options = { path: "", override: false }) => writeResource(directory, { ...event }, { ...options, type: "event" });
-var writeEventToService = (directory) => async (event, service, options = { path: "" }) => {
+var writeEvent = (directory) => async (event, options = {
+  path: "",
+  override: false,
+  format: "mdx"
+}) => writeResource(directory, { ...event }, { ...options, type: "event" });
+var writeEventToService = (directory) => async (event, service, options = { path: "", format: "mdx" }) => {
   const resourcePath = await getResourcePath(directory, service.id, service.version);
   if (!resourcePath) {
     throw new Error("Service not found");
@@ -278,8 +285,13 @@ import fs3 from "node:fs/promises";
 import { join as join4 } from "node:path";
 var getCommand = (directory) => async (id, version) => getResource(directory, id, version, { type: "command" });
 var getCommands = (directory) => async (options) => getResources(directory, { type: "commands", ...options });
-var writeCommand = (directory) => async (command, options = { path: "" }) => writeResource(directory, { ...command }, { ...options, type: "command" });
-var writeCommandToService = (directory) => async (command, service, options = { path: "" }) => {
+var writeCommand = (directory) => async (command, options = {
+  path: "",
+  override: false,
+  versionExistingContent: false,
+  format: "mdx"
+}) => writeResource(directory, { ...command }, { ...options, type: "command" });
+var writeCommandToService = (directory) => async (command, service, options = { path: "", format: "mdx" }) => {
   const resourcePath = await getResourcePath(directory, service.id, service.version);
   if (!resourcePath) {
     throw new Error("Service not found");
@@ -306,9 +318,14 @@ var commandHasVersion = (directory) => async (id, version) => {
 import fs4 from "node:fs/promises";
 import { join as join5 } from "node:path";
 var getQuery = (directory) => async (id, version) => getResource(directory, id, version, { type: "query" });
-var writeQuery = (directory) => async (query, options = { path: "" }) => writeResource(directory, { ...query }, { ...options, type: "query" });
+var writeQuery = (directory) => async (query, options = {
+  path: "",
+  override: false,
+  versionExistingContent: false,
+  format: "mdx"
+}) => writeResource(directory, { ...query }, { ...options, type: "query" });
 var getQueries = (directory) => async (options) => getResources(directory, { type: "queries", ...options });
-var writeQueryToService = (directory) => async (query, service, options = { path: "" }) => {
+var writeQueryToService = (directory) => async (query, service, options = { path: "", format: "mdx" }) => {
   const resourcePath = await getResourcePath(directory, service.id, service.version);
   if (!resourcePath) {
     throw new Error("Service not found");
@@ -335,14 +352,18 @@ var queryHasVersion = (directory) => async (id, version) => {
 
 // src/services.ts
 import fs5 from "node:fs/promises";
-import { join as join6, dirname as dirname3 } from "node:path";
+import { join as join6, dirname as dirname4 } from "node:path";
 var getService = (directory) => async (id, version) => getResource(directory, id, version, { type: "service" });
 var getServices = (directory) => async (options) => getResources(directory, {
   type: "services",
   ignore: ["**/events/**", "**/commands/**", "**/queries/**"],
   ...options
 });
-var writeService = (directory) => async (service, options = { path: "" }) => {
+var writeService = (directory) => async (service, options = {
+  path: "",
+  override: false,
+  format: "mdx"
+}) => {
   const resource = { ...service };
   if (Array.isArray(service.sends)) {
     resource.sends = uniqueVersions(service.sends);
@@ -357,7 +378,7 @@ var writeVersionedService = (directory) => async (service) => {
   const path4 = getVersionedDirectory(service.id, service.version);
   return await writeService(directory)(resource, { path: path4 });
 };
-var writeServiceToDomain = (directory) => async (service, domain, options = { path: "" }) => {
+var writeServiceToDomain = (directory) => async (service, domain, options = { path: "", format: "mdx" }) => {
   let pathForService = domain.version && domain.version !== "latest" ? `/${domain.id}/versioned/${domain.version}/services` : `/${domain.id}/services`;
   pathForService = join6(pathForService, service.id);
   await writeResource(directory, { ...service }, { ...options, path: pathForService, type: "service" });
@@ -382,7 +403,7 @@ var getSpecificationFilesForService = (directory) => async (id, version) => {
         throw new Error(`Specification file name for ${specFile} is undefined`);
       }
       const rawFile = await getFileFromResource(directory, id, { fileName }, version);
-      return { key: specFile, content: rawFile, fileName, path: join6(dirname3(filePathToService), fileName) };
+      return { key: specFile, content: rawFile, fileName, path: join6(dirname4(filePathToService), fileName) };
     });
     specs = await Promise.all(getSpecs);
   }
@@ -438,7 +459,12 @@ var getDomains = (directory) => async (options) => getResources(directory, {
   ignore: ["**/services/**", "**/events/**", "**/commands/**", "**/queries/**", "**/flows/**"],
   ...options
 });
-var writeDomain = (directory) => async (domain, options = { path: "" }) => {
+var writeDomain = (directory) => async (domain, options = {
+  path: "",
+  override: false,
+  versionExistingContent: false,
+  format: "mdx"
+}) => {
   const resource = { ...domain };
   if (Array.isArray(domain.services)) {
     resource.services = uniqueVersions(domain.services);