@graphrefly/ts 0.0.1 → 0.0.3

package/dist/adapters/nestjs/microservices.cjs

@@ -0,0 +1,841 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/adapters/nestjs/microservices.ts
+var microservices_exports = {};
+__export(microservices_exports, {
+  GRAPHREFLY_NEST_MESSAGE_BRIDGE: () => GRAPHREFLY_NEST_MESSAGE_BRIDGE,
+  GraphMessage: () => GraphMessage,
+  GraphMessageReply: () => GraphMessageReply,
+  createGraphMessageBridge: () => createGraphMessageBridge,
+  fromNestMessage: () => fromNestMessage,
+  provideGraphMessageBridge: () => provideGraphMessageBridge,
+  provideGraphMessageProviders: () => provideGraphMessageProviders
+});
+module.exports = __toCommonJS(microservices_exports);
+
+// src/adapters/nestjs.ts
+var NEST_BOUNDARY_ENVELOPE_VERSION = 1;
+var NEST_BOUNDARY_PAYLOAD_MAX_BYTES = 64 * 1024;
+var NEST_HTTP_DIAGNOSTICS_MAX_RETAINED = 100;
+var NEST_BOUNDARY_BINDINGS = /* @__PURE__ */ new WeakMap();
+function fromNestMessage(graph, opts = {}) {
+  return nestIngress(graph, "message", opts);
+}
+function toNestHttp(egress, opts = {}) {
+  const bindingId = stableBindingId("http", opts);
+  const scopedBindingId = opts.bindingId;
+  const maxDiagnostics = diagnosticsRetainedLimit(opts.maxDiagnostics);
+  const maxPayloadBytes = payloadByteLimit(opts.maxPayloadBytes);
+  const pending = /* @__PURE__ */ new Map();
+  const diagnostics = [];
+  let active = true;
+  let terminal;
+  const report = (diagnostic) => {
+    pushDiagnostic(diagnostics, diagnostic, maxDiagnostics);
+    try {
+      const phase = diagnostic.phase ?? opts.diagnosticPhase ?? "http";
+      const payload = sanitizeNestDiagnostic({ ...diagnostic, phase }, phase);
+      opts.diagnosticBoundary?.emit(payload, { payload });
+    } catch {
+    }
+  };
+  const keyOf = (requestId, requestBindingId) => requestBindingId === void 0 ? requestId : `${requestBindingId}\0${requestId}`;
+  const rejectEntry = (entry, error, envelope, message) => {
+    try {
+      entry.handle.reject(error, envelope);
+    } catch (rejectError) {
+      report({
+        kind: "reject-threw",
+        requestId: entry.requestId,
+        bindingId: entry.bindingId,
+        message,
+        error: rejectError
+      });
+    }
+  };
+  const rejectPending = (kind, error, message) => {
+    const entries = [...pending.values()];
+    pending.clear();
+    if (entries.length === 0) return 0;
+    report({ kind, bindingId: scopedBindingId, message, error });
+    for (const entry of entries) {
+      rejectEntry(entry, error, void 0, `toNestHttp(${bindingId}) pending reject threw`);
+    }
+    return entries.length;
+  };
+  const unsubscribe = egress.subscribe((msg) => {
+    if (!active) return;
+    if (msg[0] === "ERROR" || msg[0] === "COMPLETE" || msg[0] === "TEARDOWN") {
+      const error = msg[0] === "ERROR" ? msg[1] : new Error(`toNestHttp(${bindingId}) egress received ${msg[0]}`);
+      const message = `toNestHttp(${bindingId}) rejected pending requests after ${msg[0]}`;
+      terminal = { error, message };
+      const rejectedCount = rejectPending("terminal-egress", error, message);
+      if (rejectedCount === 0)
+        report({ kind: "terminal-egress", bindingId: scopedBindingId, message, error });
+      return;
+    }
+    if (msg[0] !== "DATA") return;
+    const envelope = msg[1];
+    const malformed = validateEnvelope(envelope, maxPayloadBytes);
+    if (malformed !== void 0) {
+      const correlated = malformedCorrelation(msg[1], scopedBindingId);
+      if (correlated !== void 0) {
+        const pendingKey2 = keyOf(correlated.requestId, scopedBindingId);
+        const entry2 = pending.get(pendingKey2);
+        if (entry2 !== void 0) {
+          pending.delete(pendingKey2);
+          rejectEntry(
+            entry2,
+            new Error(malformed),
+            void 0,
+            `toNestHttp(${bindingId}) rejected malformed correlated egress`
+          );
+        }
+      }
+      report({
+        kind: "malformed-egress",
+        requestId: correlated?.requestId,
+        bindingId: correlated?.bindingId,
+        message: malformed
+      });
+      return;
+    }
+    if (scopedBindingId !== void 0 && envelope.bindingId !== scopedBindingId) {
+      report({
+        kind: "binding-mismatch",
+        requestId: envelope.requestId,
+        bindingId: envelope.bindingId,
+        expectedBindingId: scopedBindingId,
+        message: `toNestHttp(${bindingId}) ignored egress for binding ${envelope.bindingId}`
+      });
+      return;
+    }
+    const pendingKey = keyOf(envelope.requestId, scopedBindingId);
+    const entry = pending.get(pendingKey);
+    if (entry === void 0) {
+      report({
+        kind: "stale-egress",
+        requestId: envelope.requestId,
+        bindingId: envelope.bindingId,
+        message: `toNestHttp(${bindingId}) ignored stale requestId ${envelope.requestId}`
+      });
+      return;
+    }
+    pending.delete(pendingKey);
+    try {
+      entry.handle.resolve(
+        opts.transform?.(envelope.payload, envelope) ?? envelope.payload,
+        envelope
+      );
+    } catch (error) {
+      report({
+        kind: "resolve-threw",
+        requestId: envelope.requestId,
+        bindingId: envelope.bindingId,
+        message: `toNestHttp(${bindingId}) response handle threw while resolving`,
+        error
+      });
+      rejectEntry(
+        entry,
+        error,
+        envelope,
+        `toNestHttp(${bindingId}) response handle threw while rejecting`
+      );
+    }
+  });
+  return {
+    kind: "http",
+    bindingId,
+    attach(registration) {
+      if (!active) throw new Error(`toNestHttp(${bindingId}) is disposed`);
+      assertNonEmptyString(registration.requestId, "toNestHttp.attach(requestId)");
+      const registrationBindingId = registration.bindingId ?? scopedBindingId;
+      if (scopedBindingId !== void 0 && registrationBindingId !== scopedBindingId) {
+        throw new Error(
+          `toNestHttp.attach expected bindingId ${scopedBindingId}, got ${registrationBindingId}`
+        );
+      }
+      if (terminal !== void 0) {
+        const entry2 = {
+          requestId: registration.requestId,
+          bindingId: registrationBindingId,
+          handle: registration.handle
+        };
+        report({
+          kind: "terminal-egress",
+          requestId: registration.requestId,
+          bindingId: registrationBindingId,
+          message: terminal.message,
+          error: terminal.error
+        });
+        rejectEntry(
+          entry2,
+          terminal.error,
+          void 0,
+          `toNestHttp(${bindingId}) terminal response handle reject threw`
+        );
+        return () => false;
+      }
+      const key = keyOf(registration.requestId, scopedBindingId);
+      if (pending.has(key)) {
+        throw new Error(`toNestHttp.attach duplicate pending requestId ${registration.requestId}`);
+      }
+      const entry = {
+        requestId: registration.requestId,
+        bindingId: registrationBindingId,
+        handle: registration.handle
+      };
+      pending.set(key, entry);
+      return () => {
+        if (pending.get(key) !== entry) return false;
+        return pending.delete(key);
+      };
+    },
+    pendingCount: () => pending.size,
+    diagnostics: () => diagnostics.slice(),
+    dispose() {
+      if (!active) return;
+      active = false;
+      rejectPending(
+        "dispose-pending",
+        new Error(`toNestHttp(${bindingId}) disposed before response resolution`),
+        `toNestHttp(${bindingId}) rejected pending requests during dispose`
+      );
+      unsubscribe();
+    }
+  };
+}
+function GraphMessage(boundary, opts = {}) {
+  return graphIngressBinding("message", boundary, opts);
+}
+function GraphMessageReply(replyNode, opts) {
+  return graphReplyBinding("message-reply", replyNode, opts, "GraphMessageReply");
+}
+function getNestBoundaryBindings(target, methodKey) {
+  const ctor = typeof target === "function" ? target : target.constructor;
+  const bindings = boundaryBindingsFor(ctor);
+  return sortBoundaryBindings(
+    methodKey === void 0 ? bindings : bindings.filter((binding) => binding.methodKey === methodKey)
+  );
+}
+function bindingRequestId(host, binding, fallback) {
+  if (binding.direction === "ingress") {
+    const requestId = requestIdFromBinding(host, binding);
+    if (requestId !== void 0) return requestId;
+  }
+  if (typeof fallback === "string") {
+    assertNonEmptyString(fallback, "requestId");
+    return fallback;
+  }
+  if (typeof fallback === "function") {
+    const requestId = fallback(host);
+    if (requestId !== void 0) assertNonEmptyString(requestId, "requestId");
+    return requestId;
+  }
+  return requestIdOf(host, {}, {});
+}
+function bindingEmitOptions(host, binding, requestId) {
+  return {
+    bindingId: binding.bindingId,
+    requestId,
+    ...bindingPayloadEmitOption(host, binding),
+    requireRequestId: requiresRequestId(binding.kind)
+  };
+}
+function sanitizeNestDiagnostic(diagnostic, defaultPhase = "adapter") {
+  const payload = {
+    kind: diagnostic.kind,
+    phase: diagnostic.phase ?? defaultPhase,
+    message: diagnostic.message,
+    ...optionalStringField("requestId", diagnostic.requestId),
+    ...optionalStringField("bindingId", diagnostic.bindingId),
+    ...optionalStringField("expectedBindingId", diagnostic.expectedBindingId),
+    ...optionalDiagnosticError(diagnostic.error)
+  };
+  assertGraphVisibleData(payload, "NestDiagnosticPayload", NEST_BOUNDARY_PAYLOAD_MAX_BYTES);
+  return payload;
+}
+function nestIngress(graph, kind, opts) {
+  const bindingId = stableBindingId(kind, opts);
+  const version = parseEnvelopeVersion(opts.version ?? NEST_BOUNDARY_ENVELOPE_VERSION, "version");
+  const maxPayloadBytes = payloadByteLimit(opts.maxPayloadBytes);
+  const node = graph.node([], null, {
+    name: opts.name,
+    meta: { adapter: "nestjs", boundary: "ingress", kind, bindingId, version }
+  });
+  return {
+    kind,
+    bindingId,
+    version,
+    node,
+    envelope(host, emitOpts = {}) {
+      const requestId = requestIdOf(host, opts, {
+        ...emitOpts,
+        requireRequestId: emitOpts.requireRequestId ?? opts.requireRequestId ?? requiresRequestId(kind)
+      });
+      const envelopeBindingId = emitOpts.bindingId ?? bindingId;
+      assertNonEmptyString(envelopeBindingId, "NestBoundaryEnvelope.bindingId");
+      const envelopeVersion = parseEnvelopeVersion(
+        emitOpts.version ?? version,
+        "NestBoundaryEnvelope.version"
+      );
+      const payload = "payload" in emitOpts ? emitOpts.payload : opts.payload !== void 0 ? opts.payload(host) : host;
+      assertGraphVisibleData(payload, "NestBoundaryEnvelope.payload", maxPayloadBytes);
+      const envelope = {
+        bindingId: envelopeBindingId,
+        version: envelopeVersion,
+        payload
+      };
+      return requestId === void 0 ? envelope : { ...envelope, requestId };
+    },
+    emit(host, emitOpts = {}) {
+      const envelope = this.envelope(host, emitOpts);
+      node.down([["DATA", envelope]]);
+      return envelope;
+    }
+  };
+}
+function stableBindingId(kind, opts) {
+  const bindingId = opts.bindingId ?? opts.name ?? `nestjs.${kind}`;
+  assertNonEmptyString(bindingId, "bindingId");
+  return bindingId;
+}
+function requiresRequestId(kind) {
+  return kind === "request" || kind === "guard" || kind === "interceptor" || kind === "error";
+}
+function requestIdFromBinding(host, binding) {
+  if (typeof binding.requestId === "string") {
+    assertNonEmptyString(binding.requestId, "requestId");
+    return binding.requestId;
+  }
+  if (typeof binding.requestId === "function") {
+    const requestId = binding.requestId(host);
+    if (requestId !== void 0) assertNonEmptyString(requestId, "requestId");
+    return requestId;
+  }
+  return void 0;
+}
+function bindingPayloadEmitOption(host, binding) {
+  return binding.payload === void 0 ? {} : { payload: binding.payload(host) };
+}
+function graphIngressBinding(kind, boundary, opts) {
+  if (boundary.kind !== kind) {
+    throw new Error(`Graph${kind} expected a ${kind} boundary, got ${boundary.kind}`);
+  }
+  const bindingId = opts.bindingId ?? boundary.bindingId;
+  assertNonEmptyString(bindingId, "bindingId");
+  return registerMeta(NEST_BOUNDARY_BINDINGS, (methodKey) => ({
+    direction: "ingress",
+    kind,
+    bindingId,
+    methodKey,
+    boundary,
+    payload: opts.payload,
+    requestId: opts.requestId,
+    order: opts.order,
+    mode: opts.mode,
+    issueResponse: opts.issueResponse,
+    protocolError: opts.protocolError
+  }));
+}
+function graphReplyBinding(kind, node, opts, decoratorName) {
+  const bindingId = opts?.bindingId;
+  if (typeof bindingId !== "string" || bindingId.length === 0) {
+    throw new Error(`${decoratorName} requires a non-empty bindingId`);
+  }
+  const replyNode = node;
+  return registerMeta(NEST_BOUNDARY_BINDINGS, (methodKey) => {
+    if (kind === "ws-ack") {
+      return {
+        direction: "egress",
+        kind,
+        bindingId,
+        methodKey,
+        ackNode: replyNode,
+        order: opts.order
+      };
+    }
+    return {
+      direction: "egress",
+      kind,
+      bindingId,
+      methodKey,
+      replyNode,
+      order: opts.order
+    };
+  });
+}
+function boundaryBindingsFor(ctor) {
+  const bindings = [];
+  const seen = /* @__PURE__ */ new Set();
+  let current = ctor;
+  while (typeof current === "function" && current !== Function.prototype) {
+    for (const binding of NEST_BOUNDARY_BINDINGS.get(current) ?? []) {
+      if (seen.has(binding)) continue;
+      seen.add(binding);
+      bindings.push(binding);
+    }
+    current = Object.getPrototypeOf(current);
+  }
+  return bindings;
+}
+function sortBoundaryBindings(bindings) {
+  return bindings.map((binding, index) => ({ binding, index })).sort((a, b) => (a.binding.order ?? 0) - (b.binding.order ?? 0) || a.index - b.index).map(({ binding }) => binding);
+}
+function requestIdOf(host, opts, emitOpts) {
+  const fromEmit = emitOpts.requestId;
+  if (fromEmit !== void 0) {
+    assertNonEmptyString(fromEmit, "requestId");
+    return fromEmit;
+  }
+  if (typeof opts.requestId === "string") {
+    assertNonEmptyString(opts.requestId, "requestId");
+    return opts.requestId;
+  }
+  if (typeof opts.requestId === "function") {
+    const requestId = opts.requestId(host);
+    if (requestId !== void 0) assertNonEmptyString(requestId, "requestId");
+    return requestId;
+  }
+  const record = host;
+  if (typeof record?.requestId === "string" && record.requestId.length > 0) return record.requestId;
+  if (typeof record?.id === "string" && record.id.length > 0) return record.id;
+  if (emitOpts.requireRequestId ?? opts.requireRequestId ?? false) {
+    throw new Error("Nest boundary ingress requires a stable requestId");
+  }
+  return void 0;
+}
+function validateEnvelope(value, maxPayloadBytes) {
+  try {
+    assertGraphVisibleData(value, "NestBoundaryEnvelope", maxPayloadBytes);
+  } catch (error) {
+    return error instanceof Error ? error.message : "egress envelope must be data-only material";
+  }
+  if (value === null || typeof value !== "object") return "egress DATA is not an envelope object";
+  const envelope = value;
+  if (typeof envelope.requestId !== "string" || envelope.requestId.length === 0) {
+    return "egress envelope requestId must be a non-empty string";
+  }
+  if (typeof envelope.bindingId !== "string" || envelope.bindingId.length === 0) {
+    return "egress envelope bindingId must be a non-empty string";
+  }
+  try {
+    parseEnvelopeVersion(envelope.version, "egress envelope version");
+  } catch {
+    return `egress envelope version must be ${NEST_BOUNDARY_ENVELOPE_VERSION}`;
+  }
+  return void 0;
+}
+function malformedCorrelation(value, scopedBindingId) {
+  if (value === null || typeof value !== "object") return void 0;
+  const requestId = value.requestId;
+  const bindingId = value.bindingId;
+  if (typeof requestId !== "string" || requestId.length === 0) return void 0;
+  if (typeof bindingId !== "string" || bindingId.length === 0) return void 0;
+  if (scopedBindingId !== void 0 && bindingId !== scopedBindingId) return void 0;
+  return { requestId, bindingId };
+}
+function parseEnvelopeVersion(value, label) {
+  if (value !== NEST_BOUNDARY_ENVELOPE_VERSION) {
+    throw new Error(`${label} must be ${NEST_BOUNDARY_ENVELOPE_VERSION}`);
+  }
+  return value;
+}
+function assertNonEmptyString(value, label) {
+  if (value.length === 0) throw new Error(`${label} must be a non-empty string`);
+}
+function optionalStringField(key, value) {
+  return value === void 0 ? {} : { [key]: value };
+}
+function optionalDiagnosticError(error) {
+  const summarized = summarizeDiagnosticError(error);
+  return summarized === void 0 ? {} : { error: summarized };
+}
+function summarizeDiagnosticError(error) {
+  if (error === void 0) return void 0;
+  if (error instanceof Error) {
+    return {
+      ...optionalDiagnosticName(safeDiagnosticString(() => error.name)),
+      message: safeDiagnosticString(() => error.message) ?? "diagnostic error"
+    };
+  }
+  if (typeof error === "string") return { message: error };
+  if (typeof error === "number" || typeof error === "boolean" || typeof error === "bigint") {
+    return { message: String(error) };
+  }
+  if (typeof error === "symbol") return { message: error.description ?? "symbol" };
+  if (typeof error === "function") return { message: "opaque diagnostic function" };
+  if (error !== null && typeof error === "object") {
+    const record = error;
+    const message = safeDiagnosticString(() => record.message);
+    if (message !== void 0) {
+      return {
+        ...optionalDiagnosticName(safeDiagnosticString(() => record.name)),
+        message
+      };
+    }
+    return { message: "opaque diagnostic error" };
+  }
+  return { message: String(error) };
+}
+function safeDiagnosticString(read) {
+  try {
+    const value = read();
+    return typeof value === "string" ? value : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function optionalDiagnosticName(name) {
+  return name === void 0 || name.length === 0 ? {} : { name };
+}
+function payloadByteLimit(value) {
+  if (value === void 0) return NEST_BOUNDARY_PAYLOAD_MAX_BYTES;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new Error("Nest boundary maxPayloadBytes must be a positive safe integer");
+  }
+  return value;
+}
+function diagnosticsRetainedLimit(value) {
+  if (value === void 0) return NEST_HTTP_DIAGNOSTICS_MAX_RETAINED;
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new Error("toNestHttp maxDiagnostics must be a non-negative safe integer");
+  }
+  return value;
+}
+function pushDiagnostic(diagnostics, diagnostic, maxDiagnostics) {
+  if (maxDiagnostics === 0) return;
+  diagnostics.push(diagnostic);
+  if (diagnostics.length > maxDiagnostics)
+    diagnostics.splice(0, diagnostics.length - maxDiagnostics);
+}
+function assertGraphVisibleData(value, path, maxPayloadBytes, seen = /* @__PURE__ */ new WeakSet()) {
+  if (value === void 0) {
+    throw new TypeError(`${path} cannot be undefined; undefined is SENTINEL/no DATA`);
+  }
+  if (value === null) return;
+  const type = typeof value;
+  if (type === "string" || type === "boolean") return;
+  if (type === "number") {
+    if (!Number.isFinite(value)) throw new TypeError(`${path} number must be finite`);
+    return;
+  }
+  if (type === "function" || type === "symbol" || type === "bigint") {
+    throw new TypeError(`${path} must be data-only; found ${type}`);
+  }
+  if (type !== "object") return;
+  if (seen.has(value)) throw new TypeError(`${path} must be acyclic data`);
+  seen.add(value);
+  if (Array.isArray(value)) {
+    try {
+      for (let i = 0; i < value.length; i += 1) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, i);
+        if (descriptor === void 0) {
+          throw new TypeError(`${path}[${i}] cannot be a sparse array hole`);
+        }
+        if (!descriptor.enumerable || !("value" in descriptor)) {
+          throw new TypeError(`${path}[${i}] must be enumerable plain data`);
+        }
+        assertGraphVisibleData(descriptor.value, `${path}[${i}]`, maxPayloadBytes, seen);
+      }
+      for (const key of Reflect.ownKeys(value)) {
+        if (key === "length") continue;
+        if (typeof key === "symbol" || !/^(0|[1-9]\d*)$/.test(key)) {
+          throw new TypeError(`${path} arrays must not carry hidden or extra properties`);
+        }
+      }
+      assertPayloadSize(value, path, maxPayloadBytes);
+    } finally {
+      seen.delete(value);
+    }
+    return;
+  }
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null) {
+    throw new TypeError(`${path} must be a plain data object or array`);
+  }
+  try {
+    for (const key of Reflect.ownKeys(value)) {
+      if (typeof key === "symbol") throw new TypeError(`${path} must not carry symbol keys`);
+      const descriptor = Object.getOwnPropertyDescriptor(value, key);
+      if (descriptor === void 0) continue;
+      if (!descriptor.enumerable || !("value" in descriptor)) {
+        throw new TypeError(`${path}.${key} must be enumerable plain data`);
+      }
+      assertGraphVisibleData(descriptor.value, `${path}.${key}`, maxPayloadBytes, seen);
+    }
+    assertPayloadSize(value, path, maxPayloadBytes);
+  } finally {
+    seen.delete(value);
+  }
+}
+function assertPayloadSize(value, path, maxPayloadBytes) {
+  const serialized = JSON.stringify(value);
+  if (serialized !== void 0 && utf8ByteLength(serialized) > maxPayloadBytes) {
+    throw new TypeError(`${path} exceeds ${maxPayloadBytes} bytes`);
+  }
+}
+function utf8ByteLength(value) {
+  let bytes = 0;
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+    if (code < 128) {
+      bytes += 1;
+    } else if (code < 2048) {
+      bytes += 2;
+    } else if (code >= 55296 && code <= 56319 && i + 1 < value.length) {
+      const next = value.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        bytes += 4;
+        i += 1;
+      } else {
+        bytes += 3;
+      }
+    } else {
+      bytes += 3;
+    }
+  }
+  return bytes;
+}
+function sameMeta(a, b) {
+  const left = a;
+  const right = b;
+  const keys = Reflect.ownKeys(left);
+  if (keys.length !== Reflect.ownKeys(right).length) return false;
+  for (const key of keys) {
+    if (!Object.is(left[key], right[key])) return false;
+  }
+  return true;
+}
+function pushUniqueMeta(registry, ctor, item) {
+  const existing = registry.get(ctor) ?? [];
+  if (existing.some((current) => sameMeta(current, item))) return;
+  registry.set(ctor, [...existing, item]);
+}
+function registerMeta(registry, meta) {
+  return ((targetOrValue, contextOrKey) => {
+    if (typeof contextOrKey === "object" && contextOrKey !== null) {
+      const methodKey = contextOrKey.name;
+      contextOrKey.addInitializer(function() {
+        const ctor2 = this.constructor;
+        pushUniqueMeta(registry, ctor2, meta(methodKey));
+      });
+      return;
+    }
+    const ctor = targetOrValue.constructor;
+    pushUniqueMeta(registry, ctor, meta(contextOrKey));
+  });
+}
+
+// src/adapters/nestjs/microservices.ts
+var GRAPHREFLY_NEST_MESSAGE_BRIDGE = /* @__PURE__ */ Symbol.for("graphrefly:nest:message-bridge");
+function provideGraphMessageBridge(opts = {}) {
+  return { provide: GRAPHREFLY_NEST_MESSAGE_BRIDGE, useValue: createGraphMessageBridge(opts) };
+}
+function provideGraphMessageProviders(opts = {}) {
+  return opts.bridge === false ? [] : [provideGraphMessageBridge(opts.bridge ?? {})];
+}
+function createGraphMessageBridge(opts = {}) {
+  return new GraphMessageBridgeImpl(opts);
+}
+var GraphMessageBridgeImpl = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  boundaries = /* @__PURE__ */ new WeakMap();
+  disposable = /* @__PURE__ */ new Set();
+  localDiagnostics = [];
+  active = true;
+  close() {
+    this.dispose();
+  }
+  onModuleDestroy() {
+    this.dispose();
+  }
+  handleMessage(target, methodKey, host, runOpts = {}) {
+    if (!this.active) throw new Error("GraphMessage native bridge is disposed");
+    const bindings = getNestBoundaryBindings(target, methodKey);
+    const ingress = bindings.filter(isMessageIngress);
+    if (ingress.length === 0) return void 0;
+    const replies = bindings.filter(isMessageReply);
+    const needsRequestId = replies.length > 0;
+    for (const binding of ingress) assertExplicitNativePayload(binding, "GraphMessage");
+    const ingressEmits = ingress.map((binding) => ({
+      binding,
+      requestId: bindingRequestId(host, binding, runOpts.requestId ?? this.opts.requestId)
+    }));
+    if (needsRequestId && ingressEmits.some((entry) => entry.requestId === void 0)) {
+      throw new Error("GraphMessage native bridge requires a stable requestId for reply egress");
+    }
+    const requestIds = uniqueDefinedStrings(ingressEmits.map((entry) => entry.requestId));
+    const cleanups = [];
+    let timeout;
+    let settled = false;
+    let resolvePromise;
+    let rejectPromise;
+    let cleaned = false;
+    const cleanupAll = () => {
+      if (cleaned) return;
+      cleaned = true;
+      for (const cleanup of cleanups) cleanup();
+      this.clearTimeout(timeout);
+    };
+    const handle = {
+      resolve(payload) {
+        if (settled) return;
+        settled = true;
+        resolvePromise?.(payload);
+      },
+      reject(error) {
+        if (settled) return;
+        settled = true;
+        rejectPromise?.(error);
+      }
+    };
+    const promise = replies.length === 0 ? void 0 : new Promise((resolve, reject) => {
+      resolvePromise = resolve;
+      rejectPromise = reject;
+    });
+    if (promise !== void 0) {
+      try {
+        for (const requestId of requestIds) {
+          for (const reply of replies) {
+            cleanups.push(
+              this.boundaryFor(reply).attach({
+                requestId,
+                bindingId: reply.bindingId,
+                handle
+              })
+            );
+          }
+        }
+      } catch (error) {
+        cleanupAll();
+        handle.reject(error);
+        return promise;
+      }
+      if (settled) {
+        cleanupAll();
+        return promise;
+      }
+      if (this.opts.timeoutMs !== void 0) {
+        timeout = setTimeout(() => {
+          cleanupAll();
+          const error = new Error(
+            `GraphMessage native bridge timed out waiting for ${requestIds[0]}`
+          );
+          this.diagnose({
+            kind: "timeout",
+            requestId: requestIds[0],
+            message: error.message,
+            error
+          });
+          handle.reject(error);
+        }, this.opts.timeoutMs);
+      }
+    }
+    try {
+      for (const { binding, requestId } of ingressEmits) {
+        binding.boundary.emit(host, {
+          ...bindingEmitOptions(host, binding, requestId),
+          requireRequestId: needsRequestId
+        });
+      }
+    } catch (error) {
+      cleanupAll();
+      throw error;
+    }
+    return promise?.finally(() => {
+      cleanupAll();
+    });
+  }
+  diagnostics() {
+    return [
+      ...this.localDiagnostics,
+      ...[...this.disposable].flatMap((boundary) => boundary.diagnostics())
+    ];
+  }
+  dispose() {
+    if (!this.active) return;
+    this.active = false;
+    for (const boundary of this.disposable) boundary.dispose();
+  }
+  boundaryFor(binding) {
+    let byBinding = this.boundaries.get(binding.replyNode);
+    if (byBinding === void 0) {
+      byBinding = /* @__PURE__ */ new Map();
+      this.boundaries.set(binding.replyNode, byBinding);
+    }
+    const existing = byBinding.get(binding.bindingId);
+    if (existing !== void 0) return existing;
+    const boundary = toNestHttp(binding.replyNode, {
+      bindingId: binding.bindingId,
+      diagnosticBoundary: this.opts.diagnosticBoundary,
+      diagnosticPhase: "message",
+      name: "nestjs.message-reply",
+      maxDiagnostics: this.opts.maxDiagnostics
+    });
+    byBinding.set(binding.bindingId, boundary);
+    this.disposable.add(boundary);
+    return boundary;
+  }
+  diagnose(diagnostic) {
+    this.localDiagnostics.push(diagnostic);
+    try {
+      const phase = diagnostic.phase ?? "message";
+      const payload = sanitizeNestDiagnostic({ ...diagnostic, phase }, phase);
+      this.opts.diagnosticBoundary?.emit(payload, { payload });
+    } catch {
+    }
+    if (this.opts.maxDiagnostics !== void 0 && this.localDiagnostics.length > this.opts.maxDiagnostics) {
+      this.localDiagnostics.splice(0, this.localDiagnostics.length - this.opts.maxDiagnostics);
+    }
+  }
+  clearTimeout(timeout) {
+    if (timeout !== void 0) clearTimeout(timeout);
+  }
+};
+function isMessageIngress(binding) {
+  return binding.direction === "ingress" && binding.kind === "message";
+}
+function isMessageReply(binding) {
+  return binding.direction === "egress" && binding.kind === "message-reply";
+}
+function assertExplicitNativePayload(binding, label) {
+  if (binding.payload === void 0) {
+    throw new Error(`${label} native bridge requires an explicit payload selector`);
+  }
+}
+function uniqueDefinedStrings(values) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) if (value !== void 0) seen.add(value);
+  return [...seen];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  GRAPHREFLY_NEST_MESSAGE_BRIDGE,
+  GraphMessage,
+  GraphMessageReply,
+  createGraphMessageBridge,
+  fromNestMessage,
+  provideGraphMessageBridge,
+  provideGraphMessageProviders
+});
+//# sourceMappingURL=microservices.cjs.map