@oselvar/c4/dist/core/index.js

Test helpers for Cloudflare Workers

import {
  globalC4ModelBuilder,
  globalC4Ready
} from "../chunk-FSPEOTJL.js";
import {
  C4ModelBuilder,
  callKey,
  camelCase,
  getUniqueCalls,
  makeObjectKey,
  objectKey
} from "../chunk-ZMBFSHSD.js";

// src/core/decorators.ts
import { basename, extname } from "node:path";
import { trace } from "@opentelemetry/api";
import ErrorStackParser from "error-stack-parser";
function C4SoftwareSystem(params) {
  return (system) => {
    globalC4ModelBuilder.addSoftwareSystem(system.name, {
      tags: params?.tags
    });
    return system;
  };
}
function C4Container({
  softwareSystem,
  tags
}) {
  return (container) => {
    globalC4ModelBuilder.addContainer(container.name, {
      softwareSystem,
      tags
    });
    return container;
  };
}
function C4Component({
  container,
  tags
}) {
  return (component) => {
    globalC4ModelBuilder.addComponent(component.name, {
      container,
      tags
    });
    return component;
  };
}
function C4Operation() {
  return function(...args) {
    if (args.length === 2 && args[1] && typeof args[1] === "object" && args[1].kind === "method") {
      const method = args[0];
      return c4OperationWrapper(method);
    } else {
      const descriptor = args[2];
      if (descriptor && typeof descriptor.value === "function") {
        const originalMethod = descriptor.value;
        descriptor.value = c4OperationWrapper(originalMethod);
      }
      return descriptor;
    }
  };
}
function c4OperationWrapper(method) {
  async function wrapper(...args) {
    const calleeName = this.constructor.name;
    const stack = ErrorStackParser.parse(new Error());
    const callerClassNameCandidates = stack.filter((frame) => !frame.fileName?.match(/\/node_modules\//)).filter((frame) => !frame.fileName?.match(/^node:internal/)).flatMap(toClassNames);
    const callerName = callerClassNameCandidates.find(
      (callerName2) => callerName2 !== calleeName && globalC4ModelBuilder.hasObject(callerName2)
    );
    const operationName = method.name;
    if (callerName) {
      globalC4ModelBuilder.addCall(callerName, calleeName, operationName);
    }
    const tracer = trace.getTracer("@oselvar/c4");
    return tracer.startActiveSpan(
      "call",
      {
        attributes: {
          callerName,
          calleeName,
          operationName
        }
      },
      async (span) => {
        try {
          return await method.apply(this, args);
        } finally {
          span.end();
        }
      }
    );
  }
  return wrapper;
}
function toClassNames(frame) {
  const classNames = [];
  const functioNameParts = frame.functionName?.split(".") || [];
  if (functioNameParts.length === 2) {
    classNames.push(functioNameParts[0]);
  }
  if (frame.fileName) {
    classNames.push(
      basename(frame.fileName, extname(frame.fileName))
    );
  }
  return classNames;
}

// src/core/makeC4Model.ts
function makeC4Model(objects, callchains) {
  return {
    objects: Object.fromEntries(objects.map((object) => [object.name, object])),
    callchains
  };
}
export {
  C4Component,
  C4Container,
  C4ModelBuilder,
  C4Operation,
  C4SoftwareSystem,
  callKey,
  camelCase,
  getUniqueCalls,
  globalC4ModelBuilder,
  globalC4Ready,
  makeC4Model,
  makeObjectKey,
  objectKey
};
//# sourceMappingURL=index.js.map