@eventcatalog/sdk 1.4.7 → 1.4.9

package/dist/index.mjs

@@ -2,12 +2,11 @@
 import { join as join11 } from "node:path";
 
 // src/events.ts
-import fs3 from "node:fs/promises";
+import fs2 from "node:fs/promises";
 import { join as join3 } from "node:path";
 
 // src/internal/utils.ts
-import { glob } from "glob";
-import fs from "node:fs/promises";
+import { globSync } from "glob";
 import fsSync from "node:fs";
 import { copy } from "fs-extra";
 import { join } from "node:path";
@@ -45,7 +44,7 @@ var findFileById = async (catalogDir, id, version) => {
 var getFiles = async (pattern, ignore = "") => {
   try {
     const ignoreList = Array.isArray(ignore) ? ignore : [ignore];
-    const files = await glob(pattern, { ignore: ["node_modules/**", ...ignoreList] });
+    const files = globSync(pattern, { ignore: ["node_modules/**", ...ignoreList] });
     return files;
   } catch (error) {
     throw new Error(`Error finding files: ${error}`);
@@ -54,18 +53,16 @@ var getFiles = async (pattern, ignore = "") => {
 var searchFilesForId = async (files, id, version) => {
   const idRegex = new RegExp(`^id:\\s*(['"]|>-)?\\s*${id}['"]?\\s*$`, "m");
   const versionRegex = new RegExp(`^version:\\s*['"]?${version}['"]?\\s*$`, "m");
-  const matches = await Promise.all(
-    files.map(async (file) => {
-      const content = await fs.readFile(file, "utf-8");
-      const hasIdMatch = content.match(idRegex);
-      if (version && !content.match(versionRegex)) {
-        return void 0;
-      }
-      if (hasIdMatch) {
-        return file;
-      }
-    })
-  );
+  const matches = files.map((file) => {
+    const content = fsSync.readFileSync(file, "utf-8");
+    const hasIdMatch = content.match(idRegex);
+    if (version && !content.match(versionRegex)) {
+      return void 0;
+    }
+    if (hasIdMatch) {
+      return file;
+    }
+  });
   return matches.filter(Boolean).filter((file) => file !== void 0);
 };
 var copyDir = async (catalogDir, source, target, filter) => {
@@ -96,7 +93,7 @@ var uniqueVersions = (messages) => {
 // src/internal/resources.ts
 import { dirname, join as join2 } from "path";
 import matter2 from "gray-matter";
-import fs2 from "node:fs/promises";
+import fs from "node:fs/promises";
 import fsSync2 from "node:fs";
 import { satisfies as satisfies2 } from "semver";
 import { lock, unlock } from "proper-lockfile";
@@ -114,7 +111,7 @@ var versionResource = async (catalogDir, id) => {
   await copyDir(catalogDir, sourceDirectory, targetDirectory, (src) => {
     return !src.includes("versioned");
   });
-  await fs2.readdir(sourceDirectory).then(async (resourceFiles) => {
+  await fs.readdir(sourceDirectory).then(async (resourceFiles) => {
     await Promise.all(
       resourceFiles.map(async (file2) => {
         if (file2 !== "versioned") {
@@ -195,14 +192,14 @@ var rmResourceById = async (catalogDir, id, version, options) => {
   if (options?.persistFiles) {
     await Promise.all(
       matchedFiles.map(async (file) => {
-        await fs2.rm(file, { recursive: true });
+        await fs.rm(file, { recursive: true });
       })
     );
   } else {
     await Promise.all(
       matchedFiles.map(async (file) => {
         const directory = dirname(file);
-        await fs2.rm(directory, { recursive: true, force: true });
+        await fs.rm(directory, { recursive: true, force: true });
       })
     );
   }
@@ -215,7 +212,7 @@ var addFileToResource = async (catalogDir, id, file, version) => {
 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 fs2.access(join2(dirname(pathToResource), file.fileName)).then(() => true).catch(() => false);
+  const exists = await fs.access(join2(dirname(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");
 };
@@ -233,7 +230,7 @@ var writeEventToService = (directory) => async (event, service, options = { path
   await writeResource(directory, { ...event }, { ...options, path: pathForEvent, type: "event" });
 };
 var rmEvent = (directory) => async (path) => {
-  await fs3.rm(join3(directory, path), { recursive: true });
+  await fs2.rm(join3(directory, path), { recursive: true });
 };
 var rmEventById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "event", persistFiles });
@@ -249,7 +246,7 @@ var eventHasVersion = (directory) => async (id, version) => {
 };
 
 // src/commands.ts
-import fs4 from "node:fs/promises";
+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 });
@@ -260,7 +257,7 @@ var writeCommandToService = (directory) => async (command, service, options = {
   await writeResource(directory, { ...command }, { ...options, path: pathForEvent, type: "command" });
 };
 var rmCommand = (directory) => async (path) => {
-  await fs4.rm(join4(directory, path), { recursive: true });
+  await fs3.rm(join4(directory, path), { recursive: true });
 };
 var rmCommandById = (directory) => async (id, version, persistFiles) => rmResourceById(directory, id, version, { type: "command", persistFiles });
 var versionCommand = (directory) => async (id) => versionResource(directory, id);
@@ -274,7 +271,7 @@ var commandHasVersion = (directory) => async (id, version) => {
 };
 
 // src/queries.ts
-import fs5 from "node:fs/promises";
+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" });
@@ -285,7 +282,7 @@ var writeQueryToService = (directory) => async (query, service, options = { path
   await writeResource(directory, { ...query }, { ...options, path: pathForQuery, type: "query" });
 };
 var rmQuery = (directory) => async (path) => {
-  await fs5.rm(join5(directory, path), { recursive: true });
+  await fs4.rm(join5(directory, path), { recursive: true });
 };
 var rmQueryById = (directory) => async (id, version, persistFiles) => {
   await rmResourceById(directory, id, version, { type: "query", persistFiles });
@@ -301,7 +298,7 @@ var queryHasVersion = (directory) => async (id, version) => {
 };
 
 // src/services.ts
-import fs6 from "node:fs/promises";
+import fs5 from "node:fs/promises";
 import { join as join6, dirname as dirname2 } from "node:path";
 var getService = (directory) => async (id, version) => getResource(directory, id, version, { type: "service" });
 var getServices = (directory) => async (options) => getResources(directory, {
@@ -331,7 +328,7 @@ var writeServiceToDomain = (directory) => async (service, domain, options = { pa
 };
 var versionService = (directory) => async (id) => versionResource(directory, id);
 var rmService = (directory) => async (path) => {
-  await fs6.rm(join6(directory, path), { recursive: true });
+  await fs5.rm(join6(directory, path), { recursive: true });
 };
 var rmServiceById = (directory) => async (id, version, persistFiles) => rmResourceById(directory, id, version, { type: "service", persistFiles });
 var addFileToService = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version);
@@ -395,12 +392,12 @@ var serviceHasVersion = (directory) => async (id, version) => {
 };
 
 // src/domains.ts
-import fs7 from "node:fs/promises";
+import fs6 from "node:fs/promises";
 import { join as join7 } from "node:path";
 var getDomain = (directory) => async (id, version) => getResource(directory, id, version, { type: "domain" });
 var getDomains = (directory) => async (options) => getResources(directory, {
   type: "domains",
-  ignore: ["**/services/**", "**/events/**", "**/commands/**", "**/queries/**"],
+  ignore: ["**/services/**", "**/events/**", "**/commands/**", "**/queries/**", "**/flows/**"],
   ...options
 });
 var writeDomain = (directory) => async (domain, options = { path: "" }) => {
@@ -412,7 +409,7 @@ var writeDomain = (directory) => async (domain, options = { path: "" }) => {
 };
 var versionDomain = (directory) => async (id) => versionResource(directory, id);
 var rmDomain = (directory) => async (path) => {
-  await fs7.rm(join7(directory, path), { recursive: true });
+  await fs6.rm(join7(directory, path), { recursive: true });
 };
 var rmDomainById = (directory) => async (id, version, persistFiles) => rmResourceById(directory, id, version, { type: "domain", persistFiles });
 var addFileToDomain = (directory) => async (id, file, version) => addFileToResource(directory, id, file, version);
@@ -435,13 +432,13 @@ var addServiceToDomain = (directory) => async (id, service, version) => {
 };
 
 // src/channels.ts
-import fs8 from "node:fs/promises";
+import fs7 from "node:fs/promises";
 import { join as join8 } from "node:path";
 var getChannel = (directory) => async (id, version) => getResource(directory, id, version, { type: "channel" });
 var getChannels = (directory) => async (options) => getResources(directory, { type: "channels", ...options });
 var writeChannel = (directory) => async (channel, options = { path: "" }) => writeResource(directory, { ...channel }, { ...options, type: "channel" });
 var rmChannel = (directory) => async (path) => {
-  await fs8.rm(join8(directory, path), { recursive: true });
+  await fs7.rm(join8(directory, path), { recursive: true });
 };
 var rmChannelById = (directory) => async (id, version, persistFiles) => rmResourceById(directory, id, version, { type: "channel", persistFiles });
 var versionChannel = (directory) => async (id) => versionResource(directory, id);
@@ -487,7 +484,7 @@ var addMessageToChannel = (directory, collection) => async (id, _message, versio
 };
 
 // src/teams.ts
-import fs9 from "node:fs/promises";
+import fs8 from "node:fs/promises";
 import fsSync3 from "node:fs";
 import { join as join9 } from "node:path";
 import matter3 from "gray-matter";
@@ -529,7 +526,7 @@ var writeTeam = (catalogDir) => async (team, options = {}) => {
   fsSync3.writeFileSync(join9(catalogDir, "", `${resource.id}.md`), document);
 };
 var rmTeamById = (catalogDir) => async (id) => {
-  await fs9.rm(join9(catalogDir, `${id}.md`), { recursive: true });
+  await fs8.rm(join9(catalogDir, `${id}.md`), { recursive: true });
 };
 
 // src/users.ts