@eventcatalog/sdk 2.3.7 → 2.5.0

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 import { EventCatalogObject } from './eventcatalog.js';
 import { Event, Command, Query, Channel, Service, Domain, UbiquitousLanguageDictionary, Team, User, CustomDoc } from './types.d.js';
+export { Badge, BaseSchema, ChannelPointer, Message, ResourceGroup, ResourcePointer, Specifications, UbiquitousLanguage } from './types.d.js';
 
 /**
  * Init the SDK for EventCatalog
@@ -14,7 +15,9 @@ declare const _default: (path: string) => {
      * @param version - Optional id of the version to get (supports semver)
      * @returns Event|Undefined
      */
-    getEvent: (id: string, version?: string) => Promise<Event>;
+    getEvent: (id: string, version?: string, options?: {
+        attachSchema?: boolean;
+    }) => Promise<Event>;
     /**
      * Returns all events from EventCatalog
      * @param latestOnly - optional boolean, set to true to get only latest versions
@@ -22,6 +25,7 @@ declare const _default: (path: string) => {
      */
     getEvents: (options?: {
         latestOnly?: boolean;
+        attachSchema?: boolean;
     }) => Promise<Event[]>;
     /**
      * Adds an event to EventCatalog
@@ -111,7 +115,9 @@ declare const _default: (path: string) => {
      * @param version - Optional id of the version to get (supports semver)
      * @returns Command|Undefined
      */
-    getCommand: (id: string, version?: string) => Promise<Command>;
+    getCommand: (id: string, version?: string, options?: {
+        attachSchema?: boolean;
+    }) => Promise<Command>;
     /**
      * Returns all commands from EventCatalog
      * @param latestOnly - optional boolean, set to true to get only latest versions
@@ -119,6 +125,7 @@ declare const _default: (path: string) => {
      */
     getCommands: (options?: {
         latestOnly?: boolean;
+        attachSchema?: boolean;
     }) => Promise<Command[]>;
     /**
      * Adds an command to EventCatalog
@@ -208,7 +215,9 @@ declare const _default: (path: string) => {
      * @param version - Optional id of the version to get (supports semver)
      * @returns Query|Undefined
      */
-    getQuery: (id: string, version?: string) => Promise<Query>;
+    getQuery: (id: string, version?: string, options?: {
+        attachSchema?: boolean;
+    }) => Promise<Query>;
     /**
      * Returns all queries from EventCatalog
      * @param latestOnly - optional boolean, set to true to get only latest versions
@@ -216,6 +225,7 @@ declare const _default: (path: string) => {
      */
     getQueries: (options?: {
         latestOnly?: boolean;
+        attachSchema?: boolean;
     }) => Promise<Query[]>;
     /**
      * Adds a query to EventCatalog
@@ -240,7 +250,12 @@ declare const _default: (path: string) => {
      */
     writeQueryToService: (query: Query, service: {
         id: string;
-        version?: string;
+        version? /**
+         * Returns a command from EventCatalog
+         * @param id - The id of the command to retrieve
+         * @param version - Optional id of the version to get (supports semver)
+         * @returns Command|Undefined
+         */: string;
     }, options?: {
         path?: string;
         format?: "md" | "mdx";
@@ -823,4 +838,4 @@ declare const _default: (path: string) => {
     } | undefined>;
 };
 
-export { _default as default };
+export { Channel, Command, CustomDoc, Domain, Event, Query, Service, Team, UbiquitousLanguageDictionary, User, _default as default };

package/dist/index.js

@@ -221,9 +221,22 @@ var writeResource = async (catalogDir, resource, options = {
   }
 };
 var getResource = async (catalogDir, id, version, options) => {
+  const attachSchema = options?.attachSchema || false;
   const file = await findFileById(catalogDir, id, version);
   if (!file) return;
   const { data, content } = import_gray_matter2.default.read(file);
+  if (attachSchema && data?.schemaPath) {
+    const resourceDirectory = (0, import_path.dirname)(file);
+    const pathToSchema = (0, import_path.join)(resourceDirectory, data.schemaPath);
+    if (import_node_fs2.default.existsSync(pathToSchema)) {
+      const schema = import_node_fs2.default.readFileSync(pathToSchema, "utf8");
+      try {
+        data.schema = JSON.parse(schema);
+      } catch (error) {
+        data.schema = schema;
+      }
+    }
+  }
   return {
     ...data,
     markdown: content.trim()
@@ -242,7 +255,8 @@ var getResources = async (catalogDir, {
   type,
   latestOnly = false,
   ignore = [],
-  pattern = ""
+  pattern = "",
+  attachSchema = false
 }) => {
   const ignoreList = latestOnly ? `**/versioned/**` : "";
   const filePattern = pattern || `${catalogDir}/**/${type}/**/index.{md,mdx}`;
@@ -250,6 +264,18 @@ var getResources = async (catalogDir, {
   if (files.length === 0) return;
   return files.map((file) => {
     const { data, content } = import_gray_matter2.default.read(file);
+    if (attachSchema && data?.schemaPath) {
+      const resourceDirectory = (0, import_path.dirname)(file);
+      const pathToSchema = (0, import_path.join)(resourceDirectory, data.schemaPath);
+      if (import_node_fs2.default.existsSync(pathToSchema)) {
+        const schema = import_node_fs2.default.readFileSync(pathToSchema, "utf8");
+        try {
+          data.schema = JSON.parse(schema);
+        } catch (error) {
+          data.schema = schema;
+        }
+      }
+    }
     return {
       ...data,
       markdown: content.trim()
@@ -300,7 +326,7 @@ var getVersionedDirectory = (sourceDirectory, version) => {
 };
 
 // src/events.ts
-var getEvent = (directory) => async (id, version) => getResource(directory, id, version, { type: "event" });
+var getEvent = (directory) => async (id, version, options) => getResource(directory, id, version, { type: "event", ...options });
 var getEvents = (directory) => async (options) => getResources(directory, { type: "events", ...options });
 var writeEvent = (directory) => async (event, options = {
   path: "",
@@ -335,7 +361,7 @@ var eventHasVersion = (directory) => async (id, version) => {
 // src/commands.ts
 var import_promises3 = __toESM(require("fs/promises"));
 var import_node_path3 = require("path");
-var getCommand = (directory) => async (id, version) => getResource(directory, id, version, { type: "command" });
+var getCommand = (directory) => async (id, version, options) => getResource(directory, id, version, { type: "command", ...options });
 var getCommands = (directory) => async (options) => getResources(directory, { type: "commands", ...options });
 var writeCommand = (directory) => async (command, options = {
   path: "",
@@ -369,7 +395,7 @@ var commandHasVersion = (directory) => async (id, version) => {
 // src/queries.ts
 var import_promises4 = __toESM(require("fs/promises"));
 var import_node_path4 = require("path");
-var getQuery = (directory) => async (id, version) => getResource(directory, id, version, { type: "query" });
+var getQuery = (directory) => async (id, version, options) => getResource(directory, id, version, { type: "query", ...options });
 var writeQuery = (directory) => async (query, options = {
   path: "",
   override: false,
@@ -639,101 +665,14 @@ var addMessageToChannel = (directory, collection) => async (id, _message, versio
   await writeMessage(pathToResource)(message, { format: extension === ".md" ? "md" : "mdx" });
 };
 
-// src/eventcatalog.ts
-var import_fs = __toESM(require("fs"));
-var import_node_path8 = __toESM(require("path"));
-var DUMP_VERSION = "0.0.1";
-var getEventCatalogVersion = async (catalogDir) => {
-  try {
-    const packageJson = import_fs.default.readFileSync((0, import_node_path8.join)(catalogDir, "package.json"), "utf8");
-    const packageJsonObject = JSON.parse(packageJson);
-    return packageJsonObject["dependencies"]["@eventcatalog/core"];
-  } catch (error) {
-    return "unknown";
-  }
-};
-var hydrateResource = async (catalogDir, resources, { attachSchema = false } = {}) => {
-  return await Promise.all(
-    resources.map(async (resource) => {
-      const resourcePath = await getResourcePath(catalogDir, resource.id, resource.version);
-      let schema = "";
-      if (resource.schemaPath && resourcePath?.fullPath) {
-        const pathToSchema = import_node_path8.default.join(import_node_path8.default.dirname(resourcePath?.fullPath), resource.schemaPath);
-        if (import_fs.default.existsSync(pathToSchema)) {
-          schema = import_fs.default.readFileSync(pathToSchema, "utf8");
-        }
-      }
-      const eventcatalog = schema ? { directory: resourcePath?.directory, schema } : { directory: resourcePath?.directory };
-      return {
-        ...resource,
-        _eventcatalog: eventcatalog
-      };
-    })
-  );
-};
-var filterCollection = (collection, options) => {
-  return collection.map((item) => ({
-    ...item,
-    markdown: options?.includeMarkdown ? item.markdown : void 0
-  }));
-};
-var dumpCatalog = (directory) => async (options) => {
-  const { getDomains: getDomains2, getServices: getServices2, getEvents: getEvents2, getQueries: getQueries2, getCommands: getCommands2, getChannels: getChannels2, getTeams: getTeams2, getUsers: getUsers2 } = index_default(directory);
-  const { includeMarkdown = true } = options || {};
-  const domains = await getDomains2();
-  const services = await getServices2();
-  const events = await getEvents2();
-  const commands = await getCommands2();
-  const queries = await getQueries2();
-  const teams = await getTeams2();
-  const users = await getUsers2();
-  const channels = await getChannels2();
-  const [
-    hydratedDomains,
-    hydratedServices,
-    hydratedEvents,
-    hydratedQueries,
-    hydratedCommands,
-    hydratedTeams,
-    hydratedUsers,
-    hydratedChannels
-  ] = await Promise.all([
-    hydrateResource(directory, domains),
-    hydrateResource(directory, services),
-    hydrateResource(directory, events),
-    hydrateResource(directory, queries),
-    hydrateResource(directory, commands),
-    hydrateResource(directory, teams),
-    hydrateResource(directory, users),
-    hydrateResource(directory, channels)
-  ]);
-  return {
-    version: DUMP_VERSION,
-    catalogVersion: await getEventCatalogVersion(directory),
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    resources: {
-      domains: filterCollection(hydratedDomains, { includeMarkdown }),
-      services: filterCollection(hydratedServices, { includeMarkdown }),
-      messages: {
-        events: filterCollection(hydratedEvents, { includeMarkdown }),
-        queries: filterCollection(hydratedQueries, { includeMarkdown }),
-        commands: filterCollection(hydratedCommands, { includeMarkdown })
-      },
-      teams: filterCollection(hydratedTeams, { includeMarkdown }),
-      users: filterCollection(hydratedUsers, { includeMarkdown }),
-      channels: filterCollection(hydratedChannels, { includeMarkdown })
-    }
-  };
-};
-
 // src/custom-docs.ts
-var import_node_path9 = __toESM(require("path"));
+var import_node_path8 = __toESM(require("path"));
 var import_node_fs4 = __toESM(require("fs"));
 var import_promises8 = __toESM(require("fs/promises"));
 var import_gray_matter4 = __toESM(require("gray-matter"));
 var import_slugify = __toESM(require("slugify"));
 var getCustomDoc = (directory) => async (filePath) => {
-  const fullPath = import_node_path9.default.join(directory, filePath);
+  const fullPath = import_node_path8.default.join(directory, filePath);
   const fullPathWithExtension = fullPath.endsWith(".mdx") ? fullPath : `${fullPath}.mdx`;
   const fileExists = import_node_fs4.default.existsSync(fullPathWithExtension);
   if (!fileExists) {
@@ -752,20 +691,20 @@ var writeCustomDoc = (directory) => async (customDoc, options = { path: "" }) =>
   const { fileName, ...rest } = customDoc;
   const name = fileName || (0, import_slugify.default)(customDoc.title, { lower: true });
   const withExtension = name.endsWith(".mdx") ? name : `${name}.mdx`;
-  const fullPath = import_node_path9.default.join(directory, options.path || "", withExtension);
-  import_node_fs4.default.mkdirSync(import_node_path9.default.dirname(fullPath), { recursive: true });
+  const fullPath = import_node_path8.default.join(directory, options.path || "", withExtension);
+  import_node_fs4.default.mkdirSync(import_node_path8.default.dirname(fullPath), { recursive: true });
   const document = import_gray_matter4.default.stringify(customDoc.markdown.trim(), rest);
   import_node_fs4.default.writeFileSync(fullPath, document);
 };
 var rmCustomDoc = (directory) => async (filePath) => {
   const withExtension = filePath.endsWith(".mdx") ? filePath : `${filePath}.mdx`;
-  await import_promises8.default.rm((0, import_node_path9.join)(directory, withExtension), { recursive: true });
+  await import_promises8.default.rm((0, import_node_path8.join)(directory, withExtension), { recursive: true });
 };
 
 // src/teams.ts
 var import_promises9 = __toESM(require("fs/promises"));
 var import_node_fs5 = __toESM(require("fs"));
-var import_node_path10 = require("path");
+var import_node_path9 = require("path");
 var import_gray_matter5 = __toESM(require("gray-matter"));
 var getTeam = (catalogDir) => async (id) => {
   const files = await getFiles(`${catalogDir}/${id}.{md,mdx}`);
@@ -801,16 +740,16 @@ var writeTeam = (catalogDir) => async (team, options = {}) => {
   }
   const { markdown, ...frontmatter } = resource;
   const document = import_gray_matter5.default.stringify(markdown, frontmatter);
-  import_node_fs5.default.mkdirSync((0, import_node_path10.join)(catalogDir, ""), { recursive: true });
-  import_node_fs5.default.writeFileSync((0, import_node_path10.join)(catalogDir, "", `${resource.id}.mdx`), document);
+  import_node_fs5.default.mkdirSync((0, import_node_path9.join)(catalogDir, ""), { recursive: true });
+  import_node_fs5.default.writeFileSync((0, import_node_path9.join)(catalogDir, "", `${resource.id}.mdx`), document);
 };
 var rmTeamById = (catalogDir) => async (id) => {
-  await import_promises9.default.rm((0, import_node_path10.join)(catalogDir, `${id}.mdx`), { recursive: true });
+  await import_promises9.default.rm((0, import_node_path9.join)(catalogDir, `${id}.mdx`), { recursive: true });
 };
 
 // src/users.ts
 var import_node_fs6 = __toESM(require("fs"));
-var import_node_path11 = require("path");
+var import_node_path10 = require("path");
 var import_gray_matter6 = __toESM(require("gray-matter"));
 var getUser = (catalogDir) => async (id) => {
   const files = await getFiles(`${catalogDir}/${id}.{md,mdx}`);
@@ -848,11 +787,98 @@ var writeUser = (catalogDir) => async (user, options = {}) => {
   }
   const { markdown, ...frontmatter } = resource;
   const document = import_gray_matter6.default.stringify(markdown, frontmatter);
-  import_node_fs6.default.mkdirSync((0, import_node_path11.join)(catalogDir, ""), { recursive: true });
-  import_node_fs6.default.writeFileSync((0, import_node_path11.join)(catalogDir, "", `${resource.id}.mdx`), document);
+  import_node_fs6.default.mkdirSync((0, import_node_path10.join)(catalogDir, ""), { recursive: true });
+  import_node_fs6.default.writeFileSync((0, import_node_path10.join)(catalogDir, "", `${resource.id}.mdx`), document);
 };
 var rmUserById = (catalogDir) => async (id) => {
-  import_node_fs6.default.rmSync((0, import_node_path11.join)(catalogDir, `${id}.mdx`), { recursive: true });
+  import_node_fs6.default.rmSync((0, import_node_path10.join)(catalogDir, `${id}.mdx`), { recursive: true });
+};
+
+// src/eventcatalog.ts
+var import_fs = __toESM(require("fs"));
+var import_node_path11 = __toESM(require("path"));
+var DUMP_VERSION = "0.0.1";
+var getEventCatalogVersion = async (catalogDir) => {
+  try {
+    const packageJson = import_fs.default.readFileSync((0, import_node_path11.join)(catalogDir, "package.json"), "utf8");
+    const packageJsonObject = JSON.parse(packageJson);
+    return packageJsonObject["dependencies"]["@eventcatalog/core"];
+  } catch (error) {
+    return "unknown";
+  }
+};
+var hydrateResource = async (catalogDir, resources, { attachSchema = false } = {}) => {
+  return await Promise.all(
+    resources.map(async (resource) => {
+      const resourcePath = await getResourcePath(catalogDir, resource.id, resource.version);
+      let schema = "";
+      if (resource.schemaPath && resourcePath?.fullPath) {
+        const pathToSchema = import_node_path11.default.join(import_node_path11.default.dirname(resourcePath?.fullPath), resource.schemaPath);
+        if (import_fs.default.existsSync(pathToSchema)) {
+          schema = import_fs.default.readFileSync(pathToSchema, "utf8");
+        }
+      }
+      const eventcatalog = schema ? { directory: resourcePath?.directory, schema } : { directory: resourcePath?.directory };
+      return {
+        ...resource,
+        _eventcatalog: eventcatalog
+      };
+    })
+  );
+};
+var filterCollection = (collection, options) => {
+  return collection.map((item) => ({
+    ...item,
+    markdown: options?.includeMarkdown ? item.markdown : void 0
+  }));
+};
+var dumpCatalog = (directory) => async (options) => {
+  const { getDomains: getDomains2, getServices: getServices2, getEvents: getEvents2, getQueries: getQueries2, getCommands: getCommands2, getChannels: getChannels2, getTeams: getTeams2, getUsers: getUsers2 } = index_default(directory);
+  const { includeMarkdown = true } = options || {};
+  const domains = await getDomains2();
+  const services = await getServices2();
+  const events = await getEvents2();
+  const commands = await getCommands2();
+  const queries = await getQueries2();
+  const teams = await getTeams2();
+  const users = await getUsers2();
+  const channels = await getChannels2();
+  const [
+    hydratedDomains,
+    hydratedServices,
+    hydratedEvents,
+    hydratedQueries,
+    hydratedCommands,
+    hydratedTeams,
+    hydratedUsers,
+    hydratedChannels
+  ] = await Promise.all([
+    hydrateResource(directory, domains),
+    hydrateResource(directory, services),
+    hydrateResource(directory, events),
+    hydrateResource(directory, queries),
+    hydrateResource(directory, commands),
+    hydrateResource(directory, teams),
+    hydrateResource(directory, users),
+    hydrateResource(directory, channels)
+  ]);
+  return {
+    version: DUMP_VERSION,
+    catalogVersion: await getEventCatalogVersion(directory),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+    resources: {
+      domains: filterCollection(hydratedDomains, { includeMarkdown }),
+      services: filterCollection(hydratedServices, { includeMarkdown }),
+      messages: {
+        events: filterCollection(hydratedEvents, { includeMarkdown }),
+        queries: filterCollection(hydratedQueries, { includeMarkdown }),
+        commands: filterCollection(hydratedCommands, { includeMarkdown })
+      },
+      teams: filterCollection(hydratedTeams, { includeMarkdown }),
+      users: filterCollection(hydratedUsers, { includeMarkdown }),
+      channels: filterCollection(hydratedChannels, { includeMarkdown })
+    }
+  };
 };
 
 // src/index.ts