@eventcatalog/linter 1.0.2 → 1.0.4

package/dist/index.mjs

@@ -0,0 +1,1326 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/schemas/common.ts
+import { z } from "zod";
+var badgeSchema = z.object({
+  content: z.string(),
+  backgroundColor: z.string(),
+  textColor: z.string(),
+  icon: z.string().optional()
+});
+var ownerReferenceSchema = z.union([
+  // The ID of the user or team
+  z.string(),
+  // The full object with the ID and collection (keep compatibility with `reference`)
+  z.object({
+    id: z.string(),
+    collection: z.enum(["users", "teams"])
+  })
+]).transform(
+  // This transformation is needed to keep compatibility with `reference`.
+  // The utilities `getTeams` and `getUsers` rely on this transformation.
+  (lookup) => ({ id: typeof lookup === "string" ? lookup : lookup.id })
+);
+var specificationSchema = z.union([
+  z.object({
+    openapiPath: z.string().optional(),
+    asyncapiPath: z.string().optional()
+  }),
+  z.array(
+    z.object({
+      type: z.enum(["openapi", "asyncapi"]),
+      path: z.string(),
+      name: z.string().optional()
+    })
+  )
+]);
+var repositorySchema = z.object({
+  language: z.string().optional(),
+  url: z.string().optional()
+});
+var draftSchema = z.union([
+  z.boolean(),
+  z.object({
+    title: z.string().optional(),
+    message: z.string()
+  })
+]);
+var deprecatedSchema = z.union([
+  z.object({
+    message: z.string().optional(),
+    date: z.union([z.string(), z.date()]).optional()
+  }),
+  z.boolean().optional()
+]);
+var pointerSchema = z.object({
+  id: z.string(),
+  version: z.string().optional().default("latest")
+});
+var resourcePointerSchema = z.object({
+  id: z.string(),
+  version: z.string().optional().default("latest"),
+  type: z.enum(["service", "event", "command", "query", "flow", "channel", "domain", "user", "team"])
+});
+var channelPointerSchema = z.object({
+  parameters: z.record(z.string()).optional()
+}).merge(pointerSchema);
+var resourceReferenceSchema = pointerSchema;
+var semverSchema = z.string().refine((version) => {
+  if (version === "latest") return true;
+  if (version.includes(".x")) {
+    const xPattern = /^\d+(\.\d+)*\.x$/;
+    return xPattern.test(version);
+  }
+  if (version.startsWith("^") || version.startsWith("~")) {
+    const rangeVersion = version.substring(1);
+    const semverRegex2 = /^\d+\.\d+\.\d+(-[\w\d-.]+)?(\+[\w\d-.]+)?$/;
+    return semverRegex2.test(rangeVersion);
+  }
+  const semverRegex = /^\d+\.\d+\.\d+(-[\w\d-.]+)?(\+[\w\d-.]+)?$/;
+  return semverRegex.test(version);
+}, "Invalid semantic version format");
+var sidebarSchema = z.object({
+  label: z.string().optional(),
+  badge: z.string().optional()
+}).optional();
+var stylesSchema = z.object({
+  icon: z.string().optional(),
+  node: z.object({
+    color: z.string().optional(),
+    label: z.string().optional()
+  }).optional()
+}).optional();
+var resourceGroupSchema = z.array(
+  z.object({
+    id: z.string().optional(),
+    title: z.string().optional(),
+    items: z.array(resourcePointerSchema),
+    limit: z.number().optional().default(10),
+    sidebar: z.boolean().optional().default(true)
+  })
+).optional();
+var catalogMetadataSchema = z.object({
+  path: z.string(),
+  filePath: z.string(),
+  astroContentFilePath: z.string(),
+  publicPath: z.string(),
+  type: z.string()
+}).optional();
+var baseSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  summary: z.string().optional(),
+  version: semverSchema,
+  draft: z.union([z.boolean(), z.object({ title: z.string().optional(), message: z.string() })]).optional(),
+  badges: z.array(badgeSchema).optional(),
+  owners: z.array(ownerReferenceSchema).optional(),
+  schemaPath: z.string().optional(),
+  sidebar: sidebarSchema,
+  repository: repositorySchema.optional(),
+  specifications: specificationSchema.optional(),
+  hidden: z.boolean().optional(),
+  resourceGroups: resourceGroupSchema,
+  styles: stylesSchema,
+  deprecated: deprecatedSchema.optional(),
+  visualiser: z.boolean().optional(),
+  versions: z.array(z.string()).optional(),
+  latestVersion: z.string().optional(),
+  catalog: catalogMetadataSchema
+});
+
+// src/schemas/domain.ts
+import { z as z2 } from "zod";
+var domainSchema = z2.object({
+  services: z2.array(pointerSchema).optional(),
+  domains: z2.array(pointerSchema).optional(),
+  entities: z2.array(pointerSchema).optional()
+}).merge(baseSchema);
+
+// src/schemas/service.ts
+import { z as z3 } from "zod";
+var serviceSchema = z3.object({
+  sends: z3.array(pointerSchema).optional(),
+  receives: z3.array(pointerSchema).optional(),
+  entities: z3.array(pointerSchema).optional(),
+  writesTo: z3.array(pointerSchema).optional(),
+  readsFrom: z3.array(pointerSchema).optional()
+}).merge(baseSchema);
+
+// src/schemas/message.ts
+import { z as z4 } from "zod";
+var baseMessageSchema = z4.object({
+  producers: z4.array(z4.any()).optional(),
+  // reference('services')
+  consumers: z4.array(z4.any()).optional(),
+  // reference('services')
+  channels: z4.array(channelPointerSchema).optional(),
+  messageChannels: z4.array(z4.any()).optional()
+  // reference('channels')
+}).merge(baseSchema);
+var eventSchema = baseMessageSchema;
+var commandSchema = baseMessageSchema;
+var querySchema = baseMessageSchema;
+
+// src/schemas/channel.ts
+import { z as z5 } from "zod";
+var parameterSchema = z5.object({
+  enum: z5.array(z5.string()).optional(),
+  default: z5.string().optional(),
+  examples: z5.array(z5.string()).optional(),
+  description: z5.string().optional()
+});
+var channelSchema = z5.object({
+  address: z5.string().optional(),
+  protocols: z5.array(z5.string()).optional(),
+  parameters: z5.record(parameterSchema).optional(),
+  messages: z5.array(z5.object({ collection: z5.string(), name: z5.string(), ...pointerSchema.shape })).optional()
+}).merge(baseSchema);
+
+// src/schemas/flow.ts
+import { z as z6 } from "zod";
+var flowStep = z6.union([
+  z6.union([z6.string(), z6.number()]),
+  z6.object({
+    id: z6.union([z6.string(), z6.number()]),
+    label: z6.string().optional()
+  }).optional()
+]).optional();
+var flowStepSchema = z6.object({
+  id: z6.union([z6.string(), z6.number()]),
+  type: z6.enum(["node", "message", "user", "actor"]).optional(),
+  title: z6.string(),
+  summary: z6.string().optional(),
+  message: pointerSchema.optional(),
+  service: pointerSchema.optional(),
+  flow: pointerSchema.optional(),
+  actor: z6.object({
+    name: z6.string()
+  }).optional(),
+  custom: z6.object({
+    title: z6.string(),
+    icon: z6.string().optional(),
+    type: z6.string().optional(),
+    summary: z6.string().optional(),
+    url: z6.string().url().optional(),
+    color: z6.string().optional(),
+    properties: z6.record(z6.union([z6.string(), z6.number()])).optional(),
+    height: z6.number().optional(),
+    menu: z6.array(
+      z6.object({
+        label: z6.string(),
+        url: z6.string().url().optional()
+      })
+    ).optional()
+  }).optional(),
+  externalSystem: z6.object({
+    name: z6.string(),
+    summary: z6.string().optional(),
+    url: z6.string().url().optional()
+  }).optional(),
+  next_step: flowStep,
+  next_steps: z6.array(flowStep).optional()
+}).refine((data) => {
+  if (data.next_step && data.next_steps) return false;
+  const typesUsed = [data.message, data.service, data.flow, data.actor, data.custom].filter((v) => v).length;
+  return typesUsed === 0 || typesUsed === 1;
+});
+var flowSchema = z6.object({
+  steps: z6.array(flowStepSchema)
+}).merge(baseSchema);
+
+// src/schemas/entity.ts
+import { z as z7 } from "zod";
+var propertySchema = z7.object({
+  name: z7.string(),
+  type: z7.string(),
+  required: z7.boolean().optional(),
+  description: z7.string().optional(),
+  references: z7.string().optional(),
+  referencesIdentifier: z7.string().optional(),
+  relationType: z7.string().optional()
+});
+var entitySchema = z7.object({
+  aggregateRoot: z7.boolean().optional(),
+  identifier: z7.string().optional(),
+  properties: z7.array(propertySchema).optional(),
+  services: z7.array(z7.any()).optional(),
+  // reference('services')
+  domains: z7.array(z7.any()).optional()
+  // reference('domains')
+}).merge(baseSchema);
+
+// src/schemas/user.ts
+import { z as z8 } from "zod";
+var userSchema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  avatarUrl: z8.string().optional(),
+  role: z8.string().optional(),
+  hidden: z8.boolean().optional(),
+  email: z8.string().email().optional(),
+  slackDirectMessageUrl: z8.string().optional(),
+  msTeamsDirectMessageUrl: z8.string().optional(),
+  ownedDomains: z8.array(z8.any()).optional(),
+  // reference('domains')
+  ownedServices: z8.array(z8.any()).optional(),
+  // reference('services')
+  ownedEvents: z8.array(z8.any()).optional(),
+  // reference('events')
+  ownedCommands: z8.array(z8.any()).optional(),
+  // reference('commands')
+  ownedQueries: z8.array(z8.any()).optional(),
+  // reference('queries')
+  associatedTeams: z8.array(z8.any()).optional()
+  // reference('teams')
+});
+
+// src/schemas/team.ts
+import { z as z9 } from "zod";
+var teamSchema = z9.object({
+  id: z9.string(),
+  name: z9.string(),
+  summary: z9.string().optional(),
+  email: z9.string().email().optional(),
+  hidden: z9.boolean().optional(),
+  slackDirectMessageUrl: z9.string().optional(),
+  msTeamsDirectMessageUrl: z9.string().optional(),
+  members: z9.array(z9.any()).optional(),
+  // reference('users')
+  ownedCommands: z9.array(z9.any()).optional(),
+  // reference('commands')
+  ownedQueries: z9.array(z9.any()).optional(),
+  // reference('queries')
+  ownedDomains: z9.array(z9.any()).optional(),
+  // reference('domains')
+  ownedServices: z9.array(z9.any()).optional(),
+  // reference('services')
+  ownedEvents: z9.array(z9.any()).optional()
+  // reference('events')
+});
+
+// src/schemas/data-store.ts
+import { z as z10 } from "zod";
+var dataStoreSchema = z10.object({
+  container_type: z10.enum(["database", "cache", "objectStore", "searchIndex", "dataWarehouse", "dataLake", "externalSaaS"]),
+  technology: z10.string().optional(),
+  authoritative: z10.boolean().optional(),
+  access_mode: z10.enum(["read", "write", "readWrite", "appendOnly"]),
+  classification: z10.enum(["public", "internal", "confidential", "regulated"]),
+  residency: z10.string().optional(),
+  retention: z10.string().optional()
+}).merge(baseSchema);
+
+// src/schemas/index.ts
+var schemas = {
+  domain: domainSchema,
+  service: serviceSchema,
+  event: eventSchema,
+  command: commandSchema,
+  query: querySchema,
+  channel: channelSchema,
+  flow: flowSchema,
+  entity: entitySchema,
+  user: userSchema,
+  team: teamSchema,
+  dataStore: dataStoreSchema
+};
+
+// src/scanner/index.ts
+import fg from "fast-glob";
+import path from "path";
+var RESOURCE_PATTERNS = {
+  domain: [
+    "domains/*/index.{md,mdx}",
+    "domains/*/versioned/*/index.{md,mdx}",
+    "domains/*/subdomains/*/index.{md,mdx}",
+    "domains/*/subdomains/*/versioned/*/index.{md,mdx}"
+  ],
+  service: [
+    "domains/*/services/*/index.{md,mdx}",
+    "domains/*/services/*/versioned/*/index.{md,mdx}",
+    "domains/*/subdomains/*/services/*/index.{md,mdx}",
+    "domains/*/subdomains/*/services/*/versioned/*/index.{md,mdx}",
+    "services/*/index.{md,mdx}",
+    "services/*/versioned/*/index.{md,mdx}"
+  ],
+  event: ["**/events/*/index.{md,mdx}", "**/events/*/versioned/*/index.{md,mdx}"],
+  command: ["**/commands/*/index.{md,mdx}", "**/commands/*/versioned/*/index.{md,mdx}"],
+  query: ["**/queries/*/index.{md,mdx}", "**/queries/*/versioned/*/index.{md,mdx}"],
+  channel: ["**/channels/*/index.{md,mdx}", "**/channels/*/versioned/*/index.{md,mdx}"],
+  flow: ["**/flows/*/index.{md,mdx}", "**/flows/*/versioned/*/index.{md,mdx}"],
+  entity: ["**/entities/*/index.{md,mdx}", "**/entities/*/versioned/*/index.{md,mdx}"],
+  user: ["users/*.{md,mdx}"],
+  team: ["teams/*.{md,mdx}"],
+  dataStore: ["**/containers/*/index.{md,mdx}", "**/containers/*/versioned/*/index.{md,mdx}"]
+};
+var extractResourceInfo = (filePath, resourceType) => {
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  const relativePath = normalizedPath.split("/");
+  if (resourceType === "user" || resourceType === "team") {
+    const filename = path.basename(filePath, path.extname(filePath));
+    return { id: filename };
+  }
+  const resourceTypePattern = `${resourceType}s`;
+  const resourceTypeIndex = relativePath.findIndex((part) => part === resourceTypePattern);
+  if (resourceTypeIndex === -1) {
+    const parts2 = relativePath.slice(1, -1);
+    return { id: parts2[parts2.length - 1] };
+  }
+  const parts = relativePath.slice(resourceTypeIndex + 1, -1);
+  if (parts.length === 0) {
+    return { id: "unknown" };
+  }
+  if (parts.length >= 3 && parts[parts.length - 2] === "versioned") {
+    const version = parts[parts.length - 1];
+    const resourceId = parts.slice(0, -2).join("/");
+    return { id: resourceId, version };
+  }
+  if (resourceType === "domain" && parts.length >= 2) {
+    const versionedIndex = parts.findIndex((part) => part === "versioned");
+    if (versionedIndex !== -1 && versionedIndex < parts.length - 1) {
+      const version = parts[versionedIndex + 1];
+      const resourceId = parts.slice(0, versionedIndex).join("/");
+      return { id: resourceId, version };
+    }
+  }
+  if (parts.length === 1) {
+    return { id: parts[0] };
+  }
+  return { id: parts.join("/") };
+};
+var scanCatalogFiles = async (rootDir) => {
+  const files = [];
+  for (const [resourceType, patterns] of Object.entries(RESOURCE_PATTERNS)) {
+    const foundFiles = await fg(patterns, {
+      cwd: rootDir,
+      absolute: true,
+      onlyFiles: true,
+      followSymbolicLinks: false
+    });
+    for (const filePath of foundFiles) {
+      const relativePath = path.relative(rootDir, filePath);
+      const { id, version } = extractResourceInfo(relativePath, resourceType);
+      files.push({
+        path: filePath,
+        relativePath,
+        resourceType,
+        resourceId: id,
+        version
+      });
+    }
+  }
+  return files;
+};
+
+// src/parser/index.ts
+import fs from "fs/promises";
+import matter from "gray-matter";
+var parseFrontmatter = async (file) => {
+  try {
+    const fileContent = await fs.readFile(file.path, "utf-8");
+    const { data, content } = matter(fileContent);
+    return {
+      file,
+      frontmatter: data,
+      content,
+      raw: fileContent
+    };
+  } catch (error) {
+    return {
+      file,
+      error: error instanceof Error ? error : new Error(String(error))
+    };
+  }
+};
+var parseAllFiles = async (files) => {
+  const results = await Promise.all(files.map(parseFrontmatter));
+  const parsed = [];
+  const errors = [];
+  for (const result of results) {
+    if ("error" in result) {
+      errors.push(result);
+    } else {
+      parsed.push(result);
+    }
+  }
+  return { parsed, errors };
+};
+
+// src/validators/schema-validator.ts
+import { z as z11 } from "zod";
+var validateSchema = (parsedFile) => {
+  const { file, frontmatter } = parsedFile;
+  const schema = schemas[file.resourceType];
+  const errors = [];
+  try {
+    schema.parse(frontmatter);
+  } catch (error) {
+    if (error instanceof z11.ZodError) {
+      for (const issue of error.issues) {
+        const field = issue.path.join(".");
+        let message = issue.message;
+        if (issue.code === "invalid_type") {
+          message = `Expected ${issue.expected}, but received ${issue.received}`;
+        }
+        let rule = "schema/required-fields";
+        if (issue.code === "invalid_type") {
+          rule = "schema/valid-type";
+        } else if (issue.code === "invalid_string" && issue.validation === "email") {
+          rule = "schema/valid-email";
+        } else if (field && field.includes("version")) {
+          rule = "schema/valid-semver";
+        }
+        errors.push({
+          type: "schema",
+          resource: `${file.resourceType}/${file.resourceId}`,
+          field: field || void 0,
+          message: field ? `${field}: ${message}` : message,
+          file: file.relativePath,
+          rule
+        });
+      }
+    } else {
+      errors.push({
+        type: "schema",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        message: error instanceof Error ? error.message : String(error),
+        file: file.relativePath,
+        rule: "schema/validation-error"
+      });
+    }
+  }
+  return errors;
+};
+var validateAllSchemas = (parsedFiles) => {
+  const errors = [];
+  for (const parsedFile of parsedFiles) {
+    errors.push(...validateSchema(parsedFile));
+  }
+  return errors;
+};
+
+// src/validators/reference-validator.ts
+import semver from "semver";
+var buildResourceIndex = (parsedFiles, dependencies) => {
+  const index = {};
+  for (const parsedFile of parsedFiles) {
+    const { file, frontmatter } = parsedFile;
+    const { resourceType } = file;
+    let resourceId = file.resourceId;
+    if (frontmatter.id && typeof frontmatter.id === "string") {
+      resourceId = frontmatter.id;
+    }
+    if (!index[resourceType]) {
+      index[resourceType] = {};
+    }
+    if (!index[resourceType][resourceId]) {
+      index[resourceType][resourceId] = /* @__PURE__ */ new Set();
+    }
+    if (frontmatter.version && typeof frontmatter.version === "string") {
+      index[resourceType][resourceId].add(frontmatter.version);
+    } else {
+      index[resourceType][resourceId].add("latest");
+    }
+  }
+  if (dependencies) {
+    for (const [resourceType, entries] of Object.entries(dependencies)) {
+      if (!index[resourceType]) {
+        index[resourceType] = {};
+      }
+      for (const entry of entries) {
+        if (!index[resourceType][entry.id]) {
+          index[resourceType][entry.id] = /* @__PURE__ */ new Set();
+        }
+        index[resourceType][entry.id].add(entry.version || "latest");
+      }
+    }
+  }
+  return index;
+};
+var checkResourceExists = (ref, resourceType, index) => {
+  const resourceVersions = index[resourceType]?.[ref.id];
+  if (!resourceVersions || resourceVersions.size === 0) {
+    return false;
+  }
+  if (!ref.version) {
+    return true;
+  }
+  const refVersion = ref.version === "latest" ? ref.version : ref.version;
+  const availableVersions = Array.from(resourceVersions);
+  if (refVersion === "latest") {
+    return availableVersions.includes("latest") || availableVersions.length > 0;
+  }
+  if (availableVersions.includes(refVersion)) {
+    return true;
+  }
+  try {
+    const semverVersions = availableVersions.filter((v) => v !== "latest" && semver.valid(v));
+    for (const availableVersion of semverVersions) {
+      if (semver.satisfies(availableVersion, refVersion)) {
+        return true;
+      }
+    }
+    if (refVersion.includes(".x")) {
+      const pattern = refVersion.replace(/\.x/g, "");
+      for (const availableVersion of semverVersions) {
+        if (availableVersion.startsWith(pattern)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  } catch (error) {
+    return availableVersions.includes(refVersion);
+  }
+};
+var extractReferences = (parsedFile) => {
+  const { file, frontmatter } = parsedFile;
+  const references = [];
+  if (file.resourceType === "domain") {
+    if (frontmatter.services && Array.isArray(frontmatter.services)) {
+      frontmatter.services.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["service"], field: "services" });
+      });
+    }
+    if (frontmatter.domains && Array.isArray(frontmatter.domains)) {
+      frontmatter.domains.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["domain"], field: "domains" });
+      });
+    }
+    if (frontmatter.entities && Array.isArray(frontmatter.entities)) {
+      frontmatter.entities.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["entity"], field: "entities" });
+      });
+    }
+  }
+  if (file.resourceType === "service") {
+    if (frontmatter.sends && Array.isArray(frontmatter.sends)) {
+      frontmatter.sends.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["event", "command", "query"], field: "sends" });
+      });
+    }
+    if (frontmatter.receives && Array.isArray(frontmatter.receives)) {
+      frontmatter.receives.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["event", "command", "query"], field: "receives" });
+      });
+    }
+    if (frontmatter.entities && Array.isArray(frontmatter.entities)) {
+      frontmatter.entities.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["entity"], field: "entities" });
+      });
+    }
+    if (frontmatter.writesTo && Array.isArray(frontmatter.writesTo)) {
+      frontmatter.writesTo.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["dataStore"], field: "writesTo" });
+      });
+    }
+    if (frontmatter.readsFrom && Array.isArray(frontmatter.readsFrom)) {
+      frontmatter.readsFrom.forEach((ref) => {
+        references.push({ ref, possibleTypes: ["dataStore"], field: "readsFrom" });
+      });
+    }
+  }
+  if (file.resourceType === "flow" && frontmatter.steps && Array.isArray(frontmatter.steps)) {
+    frontmatter.steps.forEach((step, index) => {
+      if (step.message) {
+        references.push({
+          ref: step.message,
+          possibleTypes: ["event", "command", "query"],
+          field: `steps[${index}].message`
+        });
+      }
+      if (step.service) {
+        references.push({ ref: step.service, possibleTypes: ["service"], field: `steps[${index}].service` });
+      }
+    });
+  }
+  if (file.resourceType === "entity" && frontmatter.properties && Array.isArray(frontmatter.properties)) {
+    frontmatter.properties.forEach((prop, index) => {
+      if (prop.references) {
+        references.push({
+          ref: { id: prop.references },
+          possibleTypes: ["entity"],
+          field: `properties[${index}].references`
+        });
+      }
+    });
+  }
+  if (frontmatter.owners && Array.isArray(frontmatter.owners)) {
+    frontmatter.owners.forEach((owner) => {
+      references.push({ ref: { id: owner }, possibleTypes: ["user", "team"], field: "owners" });
+    });
+  }
+  if (file.resourceType === "team" && frontmatter.members && Array.isArray(frontmatter.members)) {
+    frontmatter.members.forEach((member) => {
+      references.push({ ref: { id: member }, possibleTypes: ["user"], field: "members" });
+    });
+  }
+  return references;
+};
+var extractChannelReferences = (parsedFile) => {
+  const { file, frontmatter } = parsedFile;
+  const references = [];
+  if (file.resourceType !== "service" && file.resourceType !== "domain") {
+    return references;
+  }
+  const extractFromPointers = (pointers, parentField) => {
+    if (!Array.isArray(pointers)) return;
+    pointers.forEach((pointer, idx) => {
+      if (pointer.to && Array.isArray(pointer.to)) {
+        pointer.to.forEach((channelRef, cIdx) => {
+          if (channelRef && channelRef.id) {
+            references.push({
+              ref: { id: channelRef.id, version: channelRef.version },
+              possibleTypes: ["channel"],
+              field: `${parentField}[${idx}].to[${cIdx}]`
+            });
+          }
+        });
+      }
+      if (pointer.from && Array.isArray(pointer.from)) {
+        pointer.from.forEach((channelRef, cIdx) => {
+          if (channelRef && channelRef.id) {
+            references.push({
+              ref: { id: channelRef.id, version: channelRef.version },
+              possibleTypes: ["channel"],
+              field: `${parentField}[${idx}].from[${cIdx}]`
+            });
+          }
+        });
+      }
+    });
+  };
+  if (frontmatter.sends && Array.isArray(frontmatter.sends)) {
+    extractFromPointers(frontmatter.sends, "sends");
+  }
+  if (frontmatter.receives && Array.isArray(frontmatter.receives)) {
+    extractFromPointers(frontmatter.receives, "receives");
+  }
+  return references;
+};
+var validateReferences = (parsedFiles, dependencies) => {
+  const index = buildResourceIndex(parsedFiles, dependencies);
+  const errors = [];
+  for (const parsedFile of parsedFiles) {
+    const references = extractReferences(parsedFile);
+    for (const { ref, possibleTypes, field } of references) {
+      const found = possibleTypes.some((type) => checkResourceExists(ref, type, index));
+      if (!found) {
+        const versionStr = ref.version ? ` (version: ${ref.version})` : "";
+        const typeStr = possibleTypes.length === 1 ? possibleTypes[0] : possibleTypes.join("/");
+        let rule = "refs/resource-exists";
+        if (field === "owners") {
+          rule = "refs/owner-exists";
+        } else if (field === "writesTo" || field === "readsFrom") {
+          rule = "refs/container-exists";
+        } else if (ref.version) {
+          rule = "refs/valid-version-range";
+        }
+        errors.push({
+          type: "reference",
+          resource: `${parsedFile.file.resourceType}/${parsedFile.file.resourceId}`,
+          field,
+          message: `Referenced ${typeStr} "${ref.id}"${versionStr} does not exist`,
+          file: parsedFile.file.relativePath,
+          rule
+        });
+      }
+    }
+    const channelRefs = extractChannelReferences(parsedFile);
+    for (const { ref, possibleTypes, field } of channelRefs) {
+      const found = possibleTypes.some((type) => checkResourceExists(ref, type, index));
+      if (!found) {
+        const versionStr = ref.version ? ` (version: ${ref.version})` : "";
+        errors.push({
+          type: "reference",
+          resource: `${parsedFile.file.resourceType}/${parsedFile.file.resourceId}`,
+          field,
+          message: `Referenced channel "${ref.id}"${versionStr} does not exist`,
+          file: parsedFile.file.relativePath,
+          rule: "refs/channel-exists"
+        });
+      }
+    }
+  }
+  return errors;
+};
+var validateOrphanMessages = (parsedFiles, dependencies) => {
+  const errors = [];
+  const messageTypes = ["event", "command", "query"];
+  const messageFiles = parsedFiles.filter((pf) => messageTypes.includes(pf.file.resourceType));
+  if (messageFiles.length === 0) return errors;
+  const producedMessages = /* @__PURE__ */ new Set();
+  const consumedMessages = /* @__PURE__ */ new Set();
+  for (const parsedFile of parsedFiles) {
+    const { file, frontmatter } = parsedFile;
+    if (file.resourceType === "service" || file.resourceType === "domain") {
+      if (frontmatter.sends && Array.isArray(frontmatter.sends)) {
+        frontmatter.sends.forEach((ref) => {
+          if (ref && ref.id) producedMessages.add(ref.id);
+        });
+      }
+      if (frontmatter.receives && Array.isArray(frontmatter.receives)) {
+        frontmatter.receives.forEach((ref) => {
+          if (ref && ref.id) consumedMessages.add(ref.id);
+        });
+      }
+    }
+    if (messageTypes.includes(file.resourceType)) {
+      if (frontmatter.producers && Array.isArray(frontmatter.producers) && frontmatter.producers.length > 0) {
+        const msgId = frontmatter.id || file.resourceId;
+        producedMessages.add(msgId);
+      }
+      if (frontmatter.consumers && Array.isArray(frontmatter.consumers) && frontmatter.consumers.length > 0) {
+        const msgId = frontmatter.id || file.resourceId;
+        consumedMessages.add(msgId);
+      }
+    }
+  }
+  if (dependencies) {
+    for (const [type, entries] of Object.entries(dependencies)) {
+      if (messageTypes.includes(type)) {
+        entries.forEach((entry) => {
+          producedMessages.add(entry.id);
+          consumedMessages.add(entry.id);
+        });
+      }
+    }
+  }
+  for (const parsedFile of messageFiles) {
+    const msgId = parsedFile.frontmatter.id || parsedFile.file.resourceId;
+    const isProduced = producedMessages.has(msgId);
+    const isConsumed = consumedMessages.has(msgId);
+    if (!isProduced && !isConsumed) {
+      errors.push({
+        type: "reference",
+        resource: `${parsedFile.file.resourceType}/${parsedFile.file.resourceId}`,
+        field: "id",
+        message: `${parsedFile.file.resourceType} "${msgId}" has no producer and no consumer`,
+        file: parsedFile.file.relativePath,
+        rule: "refs/orphan-messages"
+      });
+    }
+  }
+  return errors;
+};
+var validateDeprecatedReferences = (parsedFiles) => {
+  const errors = [];
+  const deprecatedIndex = {};
+  for (const parsedFile of parsedFiles) {
+    const { file, frontmatter } = parsedFile;
+    if (frontmatter.deprecated && frontmatter.deprecated !== false) {
+      const resourceId = frontmatter.id || file.resourceId;
+      const key = `${file.resourceType}:${resourceId}`;
+      if (!deprecatedIndex[key]) {
+        deprecatedIndex[key] = /* @__PURE__ */ new Set();
+      }
+      if (frontmatter.version && typeof frontmatter.version === "string") {
+        deprecatedIndex[key].add(frontmatter.version);
+      } else {
+        deprecatedIndex[key].add("*");
+      }
+    }
+  }
+  if (Object.keys(deprecatedIndex).length === 0) return errors;
+  const isDeprecated = (type, id, version) => {
+    const key = `${type}:${id}`;
+    const versions = deprecatedIndex[key];
+    if (!versions) return false;
+    if (versions.has("*")) return true;
+    if (version && versions.has(version)) return true;
+    if (!version || version === "latest") return versions.size > 0;
+    return false;
+  };
+  for (const parsedFile of parsedFiles) {
+    const references = extractReferences(parsedFile);
+    for (const { ref, possibleTypes, field } of references) {
+      if (field === "owners" || field === "members") continue;
+      for (const type of possibleTypes) {
+        if (isDeprecated(type, ref.id, ref.version)) {
+          const versionStr = ref.version ? ` (version: ${ref.version})` : "";
+          errors.push({
+            type: "reference",
+            resource: `${parsedFile.file.resourceType}/${parsedFile.file.resourceId}`,
+            field,
+            message: `Referenced ${type} "${ref.id}"${versionStr} is deprecated`,
+            file: parsedFile.file.relativePath,
+            rule: "versions/no-deprecated-references"
+          });
+          break;
+        }
+      }
+    }
+  }
+  return errors;
+};
+var validateDuplicateResourceIds = (parsedFiles) => {
+  const errors = [];
+  const seen = {};
+  for (const parsedFile of parsedFiles) {
+    const { file, frontmatter } = parsedFile;
+    const resourceId = frontmatter.id || file.resourceId;
+    const version = frontmatter.version || "latest";
+    const key = `${file.resourceType}:${resourceId}:${version}`;
+    if (seen[key]) {
+      errors.push({
+        type: "reference",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        field: "id",
+        message: `Duplicate ${file.resourceType} "${resourceId}" (version: ${version}) \u2014 also defined in ${seen[key]}`,
+        file: file.relativePath,
+        rule: "structure/duplicate-resource-ids"
+      });
+    } else {
+      seen[key] = file.relativePath;
+    }
+  }
+  return errors;
+};
+
+// src/validators/best-practices-validator.ts
+var validateBestPractices = (parsedFiles) => {
+  const errors = [];
+  for (const parsedFile of parsedFiles) {
+    const { file, frontmatter, content } = parsedFile;
+    if (!frontmatter.summary || typeof frontmatter.summary === "string" && frontmatter.summary.trim() === "") {
+      errors.push({
+        type: "schema",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        field: "summary",
+        message: "Summary is required for better documentation",
+        file: file.relativePath,
+        severity: "error",
+        rule: "best-practices/summary-required"
+      });
+    }
+    if (file.resourceType !== "user" && file.resourceType !== "team" && (!frontmatter.owners || !Array.isArray(frontmatter.owners) || frontmatter.owners.length === 0)) {
+      errors.push({
+        type: "schema",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        field: "owners",
+        message: "At least one owner is required",
+        file: file.relativePath,
+        severity: "error",
+        rule: "best-practices/owner-required"
+      });
+    }
+    if (!content || content.trim() === "") {
+      errors.push({
+        type: "schema",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        field: "description",
+        message: "Resource should have a markdown description (body content) beyond just frontmatter",
+        file: file.relativePath,
+        severity: "warning",
+        rule: "best-practices/description-required"
+      });
+    }
+    if ((file.resourceType === "event" || file.resourceType === "command" || file.resourceType === "query") && !frontmatter.schemaPath) {
+      errors.push({
+        type: "schema",
+        resource: `${file.resourceType}/${file.resourceId}`,
+        field: "schemaPath",
+        message: `${file.resourceType} should have a schemaPath defined for consumers to understand the contract`,
+        file: file.relativePath,
+        severity: "warning",
+        rule: "best-practices/schema-required"
+      });
+    }
+  }
+  return errors;
+};
+
+// src/validators/index.ts
+var validateCatalog = (parsedFiles, dependencies) => {
+  const schemaErrors = validateAllSchemas(parsedFiles);
+  const referenceErrors = validateReferences(parsedFiles, dependencies);
+  const orphanErrors = validateOrphanMessages(parsedFiles, dependencies);
+  const deprecatedRefErrors = validateDeprecatedReferences(parsedFiles);
+  const duplicateErrors = validateDuplicateResourceIds(parsedFiles);
+  const bestPracticeErrors = validateBestPractices(parsedFiles);
+  return [
+    ...schemaErrors,
+    ...referenceErrors,
+    ...orphanErrors,
+    ...deprecatedRefErrors,
+    ...duplicateErrors,
+    ...bestPracticeErrors
+  ];
+};
+
+// src/reporters/index.ts
+import chalk from "chalk";
+var formatError = (error, showFilename = true) => {
+  const lineInfo = error.line ? chalk.dim(`:${error.line}:1`) : "";
+  const filename = showFilename ? `${chalk.dim(error.file)}${lineInfo}` : "";
+  const isWarning = error.severity === "warning";
+  const severity = isWarning ? chalk.yellow("warning") : chalk.red("error");
+  const icon = isWarning ? chalk.yellow("\u26A0") : chalk.red("\u2716");
+  const errorCode = getErrorCode(error);
+  const field = error.field ? chalk.dim(`[${error.field}]`) : "";
+  const parts = [];
+  if (filename) parts.push(filename);
+  parts.push(icon, severity, error.message, field, chalk.dim(errorCode));
+  return parts.filter(Boolean).join(" ");
+};
+var getErrorCode = (error) => {
+  if (error.rule) {
+    return `(${error.rule})`;
+  }
+  if (error.type === "schema") {
+    if (error.field) {
+      if (error.message.includes("Required")) return "(@eventcatalog/required-field)";
+      if (error.message.includes("Expected")) return "(@eventcatalog/invalid-type)";
+      return "(@eventcatalog/schema-validation)";
+    }
+    return "(@eventcatalog/schema)";
+  }
+  if (error.type === "reference") {
+    return "(@eventcatalog/invalid-reference)";
+  }
+  return "(@eventcatalog/unknown)";
+};
+var formatParseError = (error, showFilename = true) => {
+  const filename = showFilename ? chalk.dim(error.file.relativePath) : "";
+  const severity = chalk.red("error");
+  const message = `Parse error: ${error.error.message}`;
+  const errorCode = chalk.dim("(@eventcatalog/parse-error)");
+  const parts = [];
+  if (filename) parts.push(filename);
+  parts.push(chalk.red("\u2716"), severity, message, errorCode);
+  return parts.filter(Boolean).join(" ");
+};
+var groupErrorsByFile = (errors) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    if (!grouped.has(error.file)) {
+      grouped.set(error.file, []);
+    }
+    grouped.get(error.file).push(error);
+  }
+  return grouped;
+};
+var reportErrors = (validationErrors, parseErrors, verbose = false) => {
+  const allErrors = [
+    ...validationErrors,
+    ...parseErrors.map((pe) => ({
+      type: "parse",
+      resource: pe.file.resourceType || "unknown",
+      message: pe.error.message,
+      file: pe.file.relativePath,
+      line: void 0
+    }))
+  ];
+  const schemaErrors = validationErrors.filter((e) => e.type === "schema");
+  const referenceErrors = validationErrors.filter((e) => e.type === "reference");
+  const warnings = validationErrors.filter((e) => e.severity === "warning");
+  const errors = [...validationErrors.filter((e) => e.severity !== "warning"), ...parseErrors];
+  const totalErrors = errors.length;
+  const totalWarnings = warnings.length;
+  if (totalErrors === 0 && totalWarnings === 0) {
+    console.log(chalk.green("\u2714 No problems found!"));
+    return {
+      totalErrors: 0,
+      totalWarnings: 0,
+      schemaErrors: 0,
+      referenceErrors: 0,
+      parseErrors: 0,
+      filesChecked: 0,
+      filesWithErrors: 0
+    };
+  }
+  const grouped = groupErrorsByFile(validationErrors);
+  const parseErrorsGrouped = groupParseErrorsByFile(parseErrors);
+  const allFiles = /* @__PURE__ */ new Set([...grouped.keys(), ...parseErrorsGrouped.keys()]);
+  console.log();
+  for (const file of Array.from(allFiles).sort()) {
+    const fileErrors = grouped.get(file) || [];
+    const fileParseErrors = parseErrorsGrouped.get(file) || [];
+    const fileErrorCount = fileErrors.length + fileParseErrors.length;
+    if (fileErrorCount === 0) continue;
+    console.log(chalk.underline(file));
+    for (const error of fileParseErrors) {
+      console.log(`  ${formatParseError(error, false)}`);
+    }
+    for (const error of fileErrors) {
+      console.log(`  ${formatError(error, false)}`);
+    }
+    const fileWarnings = fileErrors.filter((e) => e.severity === "warning").length;
+    const fileActualErrors = fileErrorCount - fileWarnings;
+    const problemText2 = fileErrorCount === 1 ? "problem" : "problems";
+    const summaryColor2 = fileActualErrors > 0 ? chalk.red : chalk.yellow;
+    const summaryIcon2 = fileActualErrors > 0 ? "\u2716" : "\u26A0";
+    console.log(summaryColor2(`
+${summaryIcon2} ${fileErrorCount} ${problemText2}
+`));
+  }
+  const filesWithErrors = allFiles.size;
+  const totalProblems = totalErrors + totalWarnings;
+  const problemText = totalProblems === 1 ? "problem" : "problems";
+  const fileText = filesWithErrors === 1 ? "file" : "files";
+  const summaryColor = totalErrors > 0 ? chalk.red.bold : chalk.yellow.bold;
+  const summaryIcon = totalErrors > 0 ? "\u2716" : "\u26A0";
+  console.log(summaryColor(`${summaryIcon} ${totalProblems} ${problemText} (${totalErrors} errors, ${totalWarnings} warnings)`));
+  console.log(chalk.dim(`  ${filesWithErrors} ${fileText} checked`));
+  return {
+    totalErrors,
+    totalWarnings,
+    schemaErrors: schemaErrors.length,
+    referenceErrors: referenceErrors.length,
+    parseErrors: parseErrors.length,
+    filesChecked: allFiles.size,
+    filesWithErrors
+  };
+};
+var groupParseErrorsByFile = (errors) => {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    const file = error.file.relativePath;
+    if (!grouped.has(file)) {
+      grouped.set(file, []);
+    }
+    grouped.get(file).push(error);
+  }
+  return grouped;
+};
+
+// src/config/index.ts
+import fs2 from "fs";
+import path2 from "path";
+var DEFAULT_IGNORE_PATTERNS = ["dependencies/**"];
+var DEFAULT_RULES = {
+  "schema/required-fields": "error",
+  "schema/valid-semver": "error",
+  "schema/valid-email": "error",
+  "refs/owner-exists": "error",
+  "refs/valid-version-range": "error",
+  "refs/resource-exists": "error",
+  "refs/channel-exists": "error",
+  "refs/container-exists": "error",
+  "refs/orphan-messages": "warn",
+  "best-practices/summary-required": "error",
+  "best-practices/owner-required": "error",
+  "best-practices/description-required": "warn",
+  "best-practices/schema-required": "warn",
+  "naming/service-id-format": "error",
+  "naming/event-id-format": "error",
+  "versions/consistent-format": "error",
+  "versions/no-deprecated": "error",
+  "versions/no-deprecated-references": "warn",
+  "structure/duplicate-resource-ids": "error"
+};
+var PLURAL_TO_SINGULAR = {
+  events: "event",
+  commands: "command",
+  queries: "query",
+  services: "service",
+  domains: "domain",
+  entities: "entity",
+  channels: "channel",
+  flows: "flow",
+  users: "user",
+  teams: "team"
+};
+var loadEventCatalogConfig = (rootDir) => {
+  const configPath = path2.join(rootDir, "eventcatalog.config.js");
+  if (!fs2.existsSync(configPath)) {
+    return {};
+  }
+  try {
+    delete __require.cache[__require.resolve(configPath)];
+    const config = __require(configPath);
+    if (!config.dependencies || typeof config.dependencies !== "object") {
+      return {};
+    }
+    const dependencies = {};
+    for (const [pluralKey, entries] of Object.entries(config.dependencies)) {
+      const singularType = PLURAL_TO_SINGULAR[pluralKey];
+      if (!singularType || !Array.isArray(entries)) continue;
+      dependencies[singularType] = entries.filter((entry) => entry && typeof entry.id === "string").map((entry) => ({ id: entry.id, version: entry.version }));
+    }
+    return dependencies;
+  } catch (error) {
+    console.warn(`Warning: Could not load eventcatalog.config.js: ${error instanceof Error ? error.message : String(error)}`);
+    return {};
+  }
+};
+var loadConfig = (rootDir) => {
+  const configPath = path2.join(rootDir, ".eventcatalogrc.js");
+  if (!fs2.existsSync(configPath)) {
+    return {
+      rules: DEFAULT_RULES,
+      ignorePatterns: DEFAULT_IGNORE_PATTERNS,
+      overrides: []
+    };
+  }
+  try {
+    delete __require.cache[__require.resolve(configPath)];
+    const config = __require(configPath);
+    const mergedConfig = {
+      rules: { ...DEFAULT_RULES, ...config.rules },
+      ignorePatterns: [...DEFAULT_IGNORE_PATTERNS, ...config.ignorePatterns || []],
+      overrides: config.overrides || []
+    };
+    return mergedConfig;
+  } catch (error) {
+    console.warn(`Warning: Could not load .eventcatalogrc.js: ${error instanceof Error ? error.message : String(error)}`);
+    return {
+      rules: DEFAULT_RULES,
+      ignorePatterns: DEFAULT_IGNORE_PATTERNS,
+      overrides: []
+    };
+  }
+};
+var parseRuleConfig = (rule) => {
+  if (Array.isArray(rule)) {
+    return {
+      severity: rule[0],
+      options: rule[1]
+    };
+  }
+  return {
+    severity: rule,
+    options: {}
+  };
+};
+var shouldIgnoreFile = (filePath, ignorePatterns) => {
+  if (!ignorePatterns || ignorePatterns.length === 0) {
+    return false;
+  }
+  const normalizedPath = filePath.replace(/\\/g, "/");
+  for (const pattern of ignorePatterns) {
+    const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
+    if (regex.test(normalizedPath)) {
+      return true;
+    }
+  }
+  return false;
+};
+var getEffectiveRules = (filePath, config) => {
+  let effectiveRules = { ...config.rules };
+  if (config.overrides) {
+    for (const override of config.overrides) {
+      const matchesFile = override.files.some((pattern) => {
+        const regex = new RegExp(pattern.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*"));
+        return regex.test(filePath);
+      });
+      if (matchesFile) {
+        effectiveRules = { ...effectiveRules, ...override.rules };
+      }
+    }
+  }
+  const parsedRules = {};
+  for (const [ruleName, ruleValue] of Object.entries(effectiveRules)) {
+    parsedRules[ruleName] = parseRuleConfig(ruleValue);
+  }
+  return parsedRules;
+};
+var applyRuleSeverity = (errors, rules) => {
+  const result = [];
+  for (const error of errors) {
+    const ruleName = mapErrorToRuleName(error);
+    const rule = rules[ruleName];
+    if (!rule || rule.severity === "off") {
+      continue;
+    }
+    result.push({
+      ...error,
+      severity: rule.severity === "warn" ? "warning" : "error"
+    });
+  }
+  return result;
+};
+var mapErrorToRuleName = (error) => {
+  if (error.rule) {
+    return error.rule;
+  }
+  if (error.type === "schema") {
+    if (error.field === "summary") {
+      return "best-practices/summary-required";
+    }
+    if (error.field === "owners") {
+      return "best-practices/owner-required";
+    }
+    if (error.message.includes("email") || error.message.includes("Invalid email")) {
+      return "schema/valid-email";
+    }
+    if (error.message.includes("version") || error.message.includes("semantic")) {
+      return "schema/valid-semver";
+    }
+    if (error.message.includes("Required") || error.message.includes("Expected")) {
+      return "schema/required-fields";
+    }
+    return "schema/required-fields";
+  }
+  if (error.type === "reference") {
+    if (error.message.includes("user") || error.message.includes("team")) {
+      return "refs/owner-exists";
+    }
+    if (error.message.includes("version")) {
+      return "refs/valid-version-range";
+    }
+    return "refs/resource-exists";
+  }
+  return "schema/required-fields";
+};
+export {
+  DEFAULT_IGNORE_PATTERNS,
+  DEFAULT_RULES,
+  applyRuleSeverity,
+  badgeSchema,
+  baseSchema,
+  buildResourceIndex,
+  catalogMetadataSchema,
+  channelPointerSchema,
+  channelSchema,
+  commandSchema,
+  dataStoreSchema,
+  deprecatedSchema,
+  domainSchema,
+  draftSchema,
+  entitySchema,
+  eventSchema,
+  extractResourceInfo,
+  flowSchema,
+  formatError,
+  formatParseError,
+  getEffectiveRules,
+  groupErrorsByFile,
+  loadConfig,
+  loadEventCatalogConfig,
+  ownerReferenceSchema,
+  parseAllFiles,
+  parseFrontmatter,
+  parseRuleConfig,
+  pointerSchema,
+  querySchema,
+  reportErrors,
+  repositorySchema,
+  resourceGroupSchema,
+  resourcePointerSchema,
+  resourceReferenceSchema,
+  scanCatalogFiles,
+  schemas,
+  semverSchema,
+  serviceSchema,
+  shouldIgnoreFile,
+  sidebarSchema,
+  specificationSchema,
+  stylesSchema,
+  teamSchema,
+  userSchema,
+  validateAllSchemas,
+  validateBestPractices,
+  validateCatalog,
+  validateDeprecatedReferences,
+  validateDuplicateResourceIds,
+  validateOrphanMessages,
+  validateReferences,
+  validateSchema
+};
+//# sourceMappingURL=index.mjs.map