@eventcatalog/sdk 1.4.6 → 1.4.8

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,9 +93,10 @@ 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";
 var versionResource = async (catalogDir, id) => {
   const files = await getFiles(`${catalogDir}/**/index.md`);
   const matchedFiles = await searchFilesForId(files, id);
@@ -113,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") {
@@ -130,24 +128,39 @@ var writeResource = async (catalogDir, resource, options = {
   versionExistingContent: false
 }) => {
   const path = options.path || `/${resource.id}`;
-  const exists = await versionExists(catalogDir, resource.id, resource.version);
-  if (exists && !options.override) {
-    throw new Error(`Failed to write ${resource.id} (${options.type}) as the version ${resource.version} already exists`);
+  const fullPath = join2(catalogDir, path);
+  fsSync2.mkdirSync(fullPath, { recursive: true });
+  const lockPath = join2(fullPath, "index.md");
+  if (!fsSync2.existsSync(lockPath)) {
+    fsSync2.writeFileSync(lockPath, "");
   }
-  const { markdown, ...frontmatter } = resource;
-  if (options.versionExistingContent && !exists) {
-    const currentResource = await getResource(catalogDir, resource.id);
-    if (currentResource) {
-      if (satisfies2(resource.version, `>${currentResource.version}`)) {
-        await versionResource(catalogDir, resource.id);
-      } else {
-        throw new Error(`New version ${resource.version} is not greater than current version ${currentResource.version}`);
+  try {
+    await lock(lockPath, {
+      retries: 5,
+      stale: 1e4
+      // 10 seconds
+    });
+    const exists = await versionExists(catalogDir, resource.id, resource.version);
+    if (exists && !options.override) {
+      throw new Error(`Failed to write ${resource.id} (${options.type}) as the version ${resource.version} already exists`);
+    }
+    const { markdown, ...frontmatter } = resource;
+    if (options.versionExistingContent && !exists) {
+      const currentResource = await getResource(catalogDir, resource.id);
+      if (currentResource) {
+        if (satisfies2(resource.version, `>${currentResource.version}`)) {
+          await versionResource(catalogDir, resource.id);
+        } else {
+          throw new Error(`New version ${resource.version} is not greater than current version ${currentResource.version}`);
+        }
       }
     }
+    const document = matter2.stringify(markdown.trim(), frontmatter);
+    fsSync2.writeFileSync(lockPath, document);
+  } finally {
+    await unlock(lockPath).catch(() => {
+    });
   }
-  const document = matter2.stringify(markdown.trim(), frontmatter);
-  fsSync2.mkdirSync(join2(catalogDir, path), { recursive: true });
-  fsSync2.writeFileSync(join2(catalogDir, path, "index.md"), document);
 };
 var getResource = async (catalogDir, id, version, options) => {
   const file = await findFileById(catalogDir, id, version);
@@ -179,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 });
       })
     );
   }
@@ -199,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");
 };
@@ -217,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 });
@@ -233,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 });
@@ -244,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);
@@ -258,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" });
@@ -269,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 });
@@ -285,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, {
@@ -315,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);
@@ -379,7 +392,7 @@ 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, {
@@ -396,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);
@@ -419,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);
@@ -471,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";
@@ -513,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