@graphrefly/ts 0.0.1 → 0.0.2

package/dist/adapters/nestjs/native.d.ts

@@ -0,0 +1,111 @@
+import { ExceptionFilter, OnModuleDestroy, ArgumentsHost, HttpException, ExecutionContext, Provider } from '@nestjs/common';
+import { F as FromCronOptions } from '../../index-CQWcE0Dw.js';
+import { DecoratorHostConstructor, NestDiagnosticIngressBoundary, NestIssueResponse, NestProtocolErrorResponse, NestHttpResponsePayload, NestGraphRunOptions } from '../nestjs.js';
+import '../../types-C9NOgNJw.js';
+import '../../messages-CAzUPPJM.js';
+import '../../graph-ho5sotHP.js';
+import '../../core/index.js';
+import '../../codec-BB7p8fJc.js';
+import '../../describe-B_A5fbXH.js';
+import '../../data/index.js';
+
+/**
+ * Nest-native provider bridge for GraphReFly boundary metadata (D484).
+ *
+ * This focused subpath is allowed to import Nest/RxJS. The dependency-light
+ * `@graphrefly/ts/adapters/nestjs` structural layer stays Nest-free.
+ */
+
+declare const GRAPHREFLY_NEST_CRON_SCHEDULER: unique symbol;
+declare const GRAPHREFLY_NEST_EXCEPTION_FILTER: unique symbol;
+declare const GRAPHREFLY_NEST_LIFECYCLE_HOOKS: unique symbol;
+interface GraphNativeHostOptions<THost = unknown> extends NestGraphRunOptions<THost> {
+    readonly host?: (context: ExecutionContext) => THost;
+    readonly diagnosticBoundary?: NestDiagnosticIngressBoundary;
+}
+interface GraphNativeHttpOptions<THost = unknown> extends GraphNativeHostOptions<THost> {
+    readonly issueResponse?: NestIssueResponse<THost>;
+    readonly protocolError?: NestProtocolErrorResponse<THost>;
+}
+interface GraphExceptionFilterTarget {
+    readonly target: DecoratorHostConstructor | object;
+    readonly methodKey: string | symbol;
+}
+interface GraphExceptionFilterProviderOptions<THost = unknown> {
+    readonly host?: (host: ArgumentsHost, exception: unknown) => THost;
+    readonly target: (host: ArgumentsHost, exception: unknown) => GraphExceptionFilterTarget | undefined;
+    readonly diagnosticBoundary?: NestDiagnosticIngressBoundary;
+    readonly requestId?: string | ((host: THost) => string | undefined);
+    readonly issueResponse?: NestIssueResponse<THost>;
+    readonly protocolError?: NestProtocolErrorResponse<THost>;
+}
+interface GraphCronProviderTarget<THost = unknown> {
+    readonly target: DecoratorHostConstructor | object;
+    readonly methodKey?: string | symbol;
+    readonly expr: string;
+    readonly tickMs?: number;
+    readonly timezone?: string;
+    readonly dst?: FromCronOptions["dst"];
+    readonly host?: (date: Date) => THost;
+}
+interface GraphCronSchedulerProviderOptions {
+    readonly targets: readonly GraphCronProviderTarget[];
+}
+interface GraphCronController {
+    check(now: Date): void;
+}
+interface GraphCronControllerOptions {
+    readonly targets: readonly GraphCronProviderTarget[];
+}
+interface GraphLifecycleProviderTarget<THost = unknown> {
+    readonly target: DecoratorHostConstructor | object;
+    readonly methodKey?: string | symbol;
+    readonly event?: "module-init" | "module-destroy";
+    readonly host?: (event: "module-init" | "module-destroy") => THost;
+}
+interface GraphLifecycleHooksProviderOptions {
+    readonly targets: readonly GraphLifecycleProviderTarget[];
+}
+interface GraphNativeHttpProviderBundleOptions<THost = unknown> {
+    readonly boundaryInterceptor?: GraphNativeHttpOptions<THost> | false;
+    readonly guard?: GraphNativeHttpOptions<THost> | false;
+    readonly guardDeniedFilter?: boolean;
+    readonly exceptionFilter?: GraphExceptionFilterProviderOptions<THost>;
+}
+interface GraphNativeProviderBundleOptions<THost = unknown> {
+    readonly http?: GraphNativeHttpProviderBundleOptions<THost> | false;
+    readonly cronScheduler?: GraphCronSchedulerProviderOptions;
+    readonly lifecycleHooks?: GraphLifecycleHooksProviderOptions;
+}
+declare function provideGraphBoundaryInterceptor<THost = unknown>(opts?: GraphNativeHttpOptions<THost>): Provider;
+declare function provideGraphGuard<THost = unknown>(opts?: GraphNativeHttpOptions<THost>): Provider;
+declare function provideGraphExceptionFilter<THost = unknown>(opts: GraphExceptionFilterProviderOptions<THost>): Provider;
+declare function createGraphExceptionFilter<THost = unknown>(opts: GraphExceptionFilterProviderOptions<THost>): ExceptionFilter & OnModuleDestroy;
+declare function provideGraphGuardDeniedFilter(): Provider;
+declare function createGraphGuardDeniedFilter(): ExceptionFilter;
+declare function provideGraphCronScheduler(opts: GraphCronSchedulerProviderOptions): Provider;
+declare function provideGraphLifecycleHooks(opts: GraphLifecycleHooksProviderOptions): Provider;
+declare function provideGraphNativeHttpProviders<THost = unknown>(opts?: GraphNativeHttpProviderBundleOptions<THost>): Provider[];
+declare function provideGraphNativeProviders<THost = unknown>(opts?: GraphNativeProviderBundleOptions<THost>): Provider[];
+declare function graphCronTarget<THost = unknown>(target: DecoratorHostConstructor | object, methodKey: string | symbol, opts: Omit<GraphCronProviderTarget<THost>, "target" | "methodKey">): GraphCronProviderTarget<THost>;
+declare function graphLifecycleTarget<THost = unknown>(target: DecoratorHostConstructor | object, methodKey: string | symbol, opts?: Omit<GraphLifecycleProviderTarget<THost>, "target" | "methodKey">): GraphLifecycleProviderTarget<THost>;
+declare function createGraphCronController(opts: GraphCronControllerOptions): GraphCronController;
+declare class GraphExceptionFilterBridge<THost> implements ExceptionFilter, OnModuleDestroy {
+    private readonly opts;
+    private readonly replies;
+    private readonly disposableReplies;
+    constructor(opts: GraphExceptionFilterProviderOptions<THost>);
+    catch(exception: unknown, host: ArgumentsHost): unknown;
+    onModuleDestroy(): void;
+    private replyBoundary;
+}
+declare class GraphGuardDeniedException extends HttpException {
+    readonly payload: NestHttpResponsePayload;
+    constructor(payload: NestHttpResponsePayload);
+}
+declare function isGraphGuardDeniedException(value: unknown): value is GraphGuardDeniedException;
+declare class GraphGuardDeniedFilter implements ExceptionFilter {
+    catch(exception: unknown, host: ArgumentsHost): unknown;
+}
+
+export { GRAPHREFLY_NEST_CRON_SCHEDULER, GRAPHREFLY_NEST_EXCEPTION_FILTER, GRAPHREFLY_NEST_LIFECYCLE_HOOKS, type GraphCronController, type GraphCronControllerOptions, type GraphCronProviderTarget, type GraphCronSchedulerProviderOptions, GraphExceptionFilterBridge, type GraphExceptionFilterProviderOptions, type GraphExceptionFilterTarget, GraphGuardDeniedException, GraphGuardDeniedFilter, type GraphLifecycleHooksProviderOptions, type GraphLifecycleProviderTarget, type GraphNativeHostOptions, type GraphNativeHttpOptions, type GraphNativeHttpProviderBundleOptions, type GraphNativeProviderBundleOptions, createGraphCronController, createGraphExceptionFilter, createGraphGuardDeniedFilter, graphCronTarget, graphLifecycleTarget, isGraphGuardDeniedException, provideGraphBoundaryInterceptor, provideGraphCronScheduler, provideGraphExceptionFilter, provideGraphGuard, provideGraphGuardDeniedFilter, provideGraphLifecycleHooks, provideGraphNativeHttpProviders, provideGraphNativeProviders };

package/dist/adapters/nestjs/native.js

@@ -0,0 +1,577 @@
+import {
+  matchesCron,
+  parseCron
+} from "../../chunk-CX6B6PO2.js";
+import "../../chunk-CJIFGJQG.js";
+import "../../chunk-SHZDP2MQ.js";
+import "../../chunk-WQIA3GFB.js";
+import "../../chunk-S6HXABGL.js";
+import {
+  bindingEmitOptions,
+  bindingRequestId,
+  createNestGraphBoundaryRunner,
+  getNestBoundaryBindings,
+  isDataIssue,
+  lowerHttpReplyPayload,
+  lowerProtocolError,
+  protocolError,
+  resolveNestMethodKey,
+  toNestHttp
+} from "../../chunk-MQEQMS7B.js";
+import "../../chunk-K7FB3JTD.js";
+import "../../chunk-DGUM43GV.js";
+
+// src/adapters/nestjs/native.ts
+import { Catch, HttpException } from "@nestjs/common";
+import { APP_GUARD, APP_INTERCEPTOR } from "@nestjs/core";
+import { from } from "rxjs";
+var GRAPHREFLY_NEST_CRON_SCHEDULER = /* @__PURE__ */ Symbol.for("graphrefly:nest:cron-scheduler");
+var GRAPHREFLY_NEST_EXCEPTION_FILTER = /* @__PURE__ */ Symbol.for("graphrefly:nest:exception-filter");
+var GRAPHREFLY_NEST_LIFECYCLE_HOOKS = /* @__PURE__ */ Symbol.for("graphrefly:nest:lifecycle-hooks");
+function provideGraphBoundaryInterceptor(opts = {}) {
+  return { provide: APP_INTERCEPTOR, useValue: new GraphBoundaryInterceptorBridge(opts) };
+}
+function provideGraphGuard(opts = {}) {
+  return { provide: APP_GUARD, useValue: new GraphGuardBridge(opts) };
+}
+function provideGraphExceptionFilter(opts) {
+  return { provide: GRAPHREFLY_NEST_EXCEPTION_FILTER, useValue: createGraphExceptionFilter(opts) };
+}
+function createGraphExceptionFilter(opts) {
+  return new GraphExceptionFilterBridge(opts);
+}
+function provideGraphGuardDeniedFilter() {
+  return GraphGuardDeniedFilter;
+}
+function createGraphGuardDeniedFilter() {
+  return new GraphGuardDeniedFilter();
+}
+function provideGraphCronScheduler(opts) {
+  return { provide: GRAPHREFLY_NEST_CRON_SCHEDULER, useValue: new GraphCronSchedulerBridge(opts) };
+}
+function provideGraphLifecycleHooks(opts) {
+  return {
+    provide: GRAPHREFLY_NEST_LIFECYCLE_HOOKS,
+    useValue: new GraphLifecycleHooksBridge(opts)
+  };
+}
+function provideGraphNativeHttpProviders(opts = {}) {
+  const providers = [];
+  if (opts.boundaryInterceptor !== false)
+    providers.push(provideGraphBoundaryInterceptor(opts.boundaryInterceptor ?? {}));
+  if (opts.guard !== false) providers.push(provideGraphGuard(opts.guard ?? {}));
+  if (opts.guardDeniedFilter ?? true) providers.push(provideGraphGuardDeniedFilter());
+  if (opts.exceptionFilter !== void 0)
+    providers.push(provideGraphExceptionFilter(opts.exceptionFilter));
+  return providers;
+}
+function provideGraphNativeProviders(opts = {}) {
+  const providers = [];
+  if (opts.http !== false) providers.push(...provideGraphNativeHttpProviders(opts.http ?? {}));
+  if (opts.cronScheduler !== void 0)
+    providers.push(provideGraphCronScheduler(opts.cronScheduler));
+  if (opts.lifecycleHooks !== void 0)
+    providers.push(provideGraphLifecycleHooks(opts.lifecycleHooks));
+  return providers;
+}
+function graphCronTarget(target, methodKey, opts) {
+  return { ...opts, target, methodKey };
+}
+function graphLifecycleTarget(target, methodKey, opts = {}) {
+  return { ...opts, target, methodKey };
+}
+function createGraphCronController(opts) {
+  return new GraphCronControllerImpl(opts);
+}
+var GraphBoundaryInterceptorBridge = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.runner = createNestGraphBoundaryRunner({
+      diagnosticBoundary: opts.diagnosticBoundary,
+      diagnosticPhase: "http"
+    });
+  }
+  runner;
+  intercept(context, next) {
+    const host = this.opts.host?.(context) ?? defaultHttpHost(context);
+    const result = this.runner.run(
+      context.getClass(),
+      methodKeyForContext(context),
+      host,
+      this.opts
+    );
+    const reply = firstHttpReply(context);
+    const value = result === void 0 ? next.handle() : Promise.resolve(result).then(
+      (payload) => writeHttpResponse(
+        context,
+        lowerHttpReplyPayload(payload, host, {
+          issueResponse: reply?.issueResponse ?? this.opts.issueResponse
+        })
+      ),
+      (errorPayload) => writeHttpResponse(
+        context,
+        lowerProtocolError(errorPayload, host, {
+          protocolError: reply?.protocolError ?? this.opts.protocolError
+        })
+      )
+    );
+    return isObservableLike(value) ? value : from(Promise.resolve(value));
+  }
+  onModuleDestroy() {
+    this.runner.dispose();
+  }
+};
+var GraphGuardBridge = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  decisions = /* @__PURE__ */ new WeakMap();
+  disposableDecisions = /* @__PURE__ */ new Set();
+  async canActivate(context) {
+    const methodKey = methodKeyForContext(context);
+    const bindings = getNestBoundaryBindings(context.getClass(), methodKey);
+    const guards = bindings.filter(isGuardIngress);
+    if (guards.length === 0) return true;
+    const decisions = bindings.filter(isGuardDecision);
+    if (decisions.length === 0) return false;
+    const host = this.opts.host?.(context) ?? defaultHttpHost(context);
+    const guardEmits = guards.map((guard) => ({
+      guard,
+      requestId: bindingRequestId(host, guard, this.opts.requestId)
+    }));
+    if (guardEmits.some((entry) => entry.requestId === void 0)) return false;
+    const requestIds = new Set(guardEmits.map((entry) => entry.requestId));
+    const cleanups = [];
+    try {
+      const pending = [];
+      for (const requestId of requestIds) {
+        for (const decision of decisions) {
+          const state = { status: "pending", binding: decision };
+          pending.push(state);
+          cleanups.push(
+            this.decisionBoundary(decision).attach({
+              requestId,
+              bindingId: decision.bindingId,
+              handle: {
+                resolve(payload) {
+                  state.status = "resolved";
+                  state.payload = payload;
+                },
+                reject(error) {
+                  state.status = "rejected";
+                  state.error = error;
+                }
+              }
+            })
+          );
+        }
+      }
+      for (const entry of guardEmits)
+        entry.guard.boundary.emit(host, bindingEmitOptions(host, entry.guard, entry.requestId));
+      const rejected = pending.find((state) => state.status === "rejected");
+      if (rejected !== void 0) {
+        throw new GraphGuardProtocolErrorException(
+          lowerProtocolError(rejected.error, host, {
+            protocolError: rejected.binding.protocolError ?? this.opts.protocolError
+          })
+        );
+      }
+      if (pending.some((state) => state.status !== "resolved")) return false;
+      const denied = pending.find(
+        (state) => state.status === "resolved" && state.payload?.kind === "deny"
+      );
+      if (denied !== void 0) {
+        throw new GraphGuardDeniedException(
+          guardDecisionResponse(denied.payload, host, {
+            issueResponse: denied.binding.issueResponse ?? this.opts.issueResponse
+          })
+        );
+      }
+      return pending.every((state) => state.payload?.kind === "allow");
+    } catch (error) {
+      if (isGraphGuardDeniedException(error) || error instanceof GraphGuardProtocolErrorException) {
+        throw error;
+      }
+      return false;
+    } finally {
+      for (const cleanup of cleanups) cleanup();
+    }
+  }
+  onModuleDestroy() {
+    for (const boundary of this.disposableDecisions) boundary.dispose();
+    this.disposableDecisions.clear();
+  }
+  decisionBoundary(binding) {
+    const node = binding.decisionNode;
+    let byBinding = this.decisions.get(node);
+    if (byBinding === void 0) {
+      byBinding = /* @__PURE__ */ new Map();
+      this.decisions.set(node, byBinding);
+    }
+    const existing = byBinding.get(binding.bindingId);
+    if (existing !== void 0) return existing;
+    const boundary = toNestHttp(binding.decisionNode, {
+      bindingId: binding.bindingId,
+      diagnosticBoundary: this.opts.diagnosticBoundary,
+      diagnosticPhase: "guard"
+    });
+    byBinding.set(binding.bindingId, boundary);
+    this.disposableDecisions.add(boundary);
+    return boundary;
+  }
+};
+var GraphExceptionFilterBridge = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  replies = /* @__PURE__ */ new WeakMap();
+  disposableReplies = /* @__PURE__ */ new Set();
+  catch(exception, host) {
+    const target = this.opts.target(host, exception);
+    if (target === void 0) throw exception;
+    const bindings = getNestBoundaryBindings(target.target, target.methodKey);
+    const filters = bindings.filter(isErrorIngress);
+    if (filters.length === 0) throw exception;
+    const nativeHost = this.opts.host?.(host, exception) ?? defaultArgumentsHost(host, exception);
+    const filterEmits = filters.map((filter) => ({
+      filter,
+      requestId: bindingRequestId(nativeHost, filter, this.opts.requestId)
+    }));
+    const handleFilters = filterEmits.filter((entry) => entry.filter.mode !== "observe");
+    const observeOnly = handleFilters.length === 0;
+    const replies = bindings.filter(isHttpReply);
+    const cleanups = [];
+    const emitFilters = () => {
+      for (const entry of filterEmits) {
+        entry.filter.boundary.emit(
+          nativeHost,
+          bindingEmitOptions(nativeHost, entry.filter, entry.requestId)
+        );
+      }
+    };
+    if (observeOnly) {
+      emitFilters();
+      throw exception;
+    }
+    const requestIds = new Set(
+      handleFilters.map((entry) => entry.requestId).filter((requestId) => requestId !== void 0)
+    );
+    if (replies.length === 0 || requestIds.size === 0) {
+      for (const entry of filterEmits) {
+        if (entry.requestId === void 0) continue;
+        entry.filter.boundary.emit(
+          nativeHost,
+          bindingEmitOptions(nativeHost, entry.filter, entry.requestId)
+        );
+      }
+      const filter = handleFilters[0]?.filter;
+      const lowered = lowerCaughtException(exception, nativeHost, {
+        issueResponse: filter?.issueResponse ?? this.opts.issueResponse,
+        protocolError: filter?.protocolError ?? this.opts.protocolError
+      });
+      return writeHttpResponse(host, lowered);
+    }
+    const pending = [];
+    try {
+      for (const requestId of requestIds) {
+        for (const reply of replies) {
+          const state = { status: "pending", reply };
+          pending.push(state);
+          cleanups.push(
+            this.replyBoundary(reply).attach({
+              requestId,
+              bindingId: reply.bindingId,
+              handle: {
+                resolve(payload) {
+                  state.status = "resolved";
+                  state.payload = payload;
+                },
+                reject(error) {
+                  state.status = "rejected";
+                  state.error = error;
+                }
+              }
+            })
+          );
+        }
+      }
+      emitFilters();
+      const resolved = pending.find((state) => state.status === "resolved");
+      if (resolved !== void 0) {
+        return writeHttpResponse(
+          host,
+          lowerHttpReplyPayload(resolved.payload, nativeHost, {
+            issueResponse: resolved.reply.issueResponse ?? handleFilters[0]?.filter.issueResponse ?? this.opts.issueResponse
+          })
+        );
+      }
+      const rejected = pending.find((state) => state.status === "rejected");
+      if (rejected !== void 0) {
+        return writeHttpResponse(
+          host,
+          lowerProtocolError(rejected.error, nativeHost, {
+            protocolError: rejected.reply.protocolError ?? handleFilters[0]?.filter.protocolError ?? this.opts.protocolError
+          })
+        );
+      }
+      const filter = handleFilters[0]?.filter;
+      return writeHttpResponse(
+        host,
+        lowerCaughtException(exception, nativeHost, {
+          issueResponse: filter?.issueResponse ?? this.opts.issueResponse,
+          protocolError: filter?.protocolError ?? this.opts.protocolError
+        })
+      );
+    } finally {
+      for (const cleanup of cleanups) cleanup();
+    }
+  }
+  onModuleDestroy() {
+    for (const boundary of this.disposableReplies) boundary.dispose();
+    this.disposableReplies.clear();
+  }
+  replyBoundary(binding) {
+    const node = binding.replyNode;
+    let byBinding = this.replies.get(node);
+    if (byBinding === void 0) {
+      byBinding = /* @__PURE__ */ new Map();
+      this.replies.set(node, 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: "filter"
+    });
+    byBinding.set(binding.bindingId, boundary);
+    this.disposableReplies.add(boundary);
+    return boundary;
+  }
+};
+var GraphCronControllerImpl = class {
+  targets;
+  constructor(opts) {
+    this.targets = opts.targets.map((target) => ({
+      target,
+      schedule: parseCron(target.expr),
+      fired: /* @__PURE__ */ new Set()
+    }));
+  }
+  check(now) {
+    for (const entry of this.targets) {
+      emitCronTarget(entry.target, entry.schedule, entry.fired, now);
+    }
+  }
+};
+var GraphCronSchedulerBridge = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  timers = [];
+  onModuleInit() {
+    try {
+      for (const target of this.opts.targets) this.startTarget(target);
+    } catch (error) {
+      this.onModuleDestroy();
+      throw error;
+    }
+  }
+  onModuleDestroy() {
+    for (const timer of this.timers.splice(0)) clearInterval(timer);
+  }
+  startTarget(target) {
+    const tickMs = target.tickMs ?? 6e4;
+    if (!Number.isFinite(tickMs) || tickMs <= 0) {
+      throw new RangeError("provideGraphCronScheduler: tickMs must be a positive finite number");
+    }
+    const controller = createGraphCronController({ targets: [target] });
+    const check = () => controller.check(/* @__PURE__ */ new Date());
+    check();
+    this.timers.push(setInterval(check, tickMs));
+  }
+};
+var GraphLifecycleHooksBridge = class {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  onModuleInit() {
+    this.emit("module-init");
+  }
+  onModuleDestroy() {
+    this.emit("module-destroy");
+  }
+  emit(event) {
+    for (const target of this.opts.targets) {
+      if (target.event !== void 0 && target.event !== event) continue;
+      const host = target.host?.(event) ?? { event };
+      for (const binding of lifecycleBindings(target)) {
+        binding.boundary.emit(host, bindingEmitOptions(host, binding, void 0));
+      }
+    }
+  }
+};
+function methodKeyForContext(context) {
+  const resolved = resolveNestMethodKey(
+    context.getClass(),
+    context.getHandler()
+  );
+  return resolved ?? context.getHandler().name;
+}
+function defaultHttpHost(context) {
+  const request = context.switchToHttp?.().getRequest?.();
+  return request ?? {};
+}
+function defaultArgumentsHost(host, exception) {
+  const request = host.switchToHttp?.().getRequest?.();
+  if (request !== void 0 && request !== null) return { ...request, exception };
+  return { exception };
+}
+function isObservableLike(value) {
+  return value !== null && typeof value === "object" && typeof value.subscribe === "function";
+}
+function isGuardIngress(binding) {
+  return binding.direction === "ingress" && binding.kind === "guard";
+}
+function isErrorIngress(binding) {
+  return binding.direction === "ingress" && binding.kind === "error";
+}
+function isHttpReply(binding) {
+  return binding.direction === "egress" && binding.kind === "http";
+}
+function isGuardDecision(binding) {
+  return binding.direction === "egress" && binding.kind === "guard-decision";
+}
+function firstHttpReply(context) {
+  return getNestBoundaryBindings(context.getClass(), methodKeyForContext(context)).find(
+    isHttpReply
+  );
+}
+function lifecycleBindings(target) {
+  return getNestBoundaryBindings(target.target, target.methodKey).filter(
+    (binding) => binding.direction === "ingress" && binding.kind === "lifecycle"
+  );
+}
+function cronBindings(target) {
+  return getNestBoundaryBindings(target.target, target.methodKey).filter(
+    (binding) => binding.direction === "ingress" && binding.kind === "cron"
+  );
+}
+function emitCronTarget(target, schedule, fired, now) {
+  if (!matchesCron(schedule, now, { timezone: target.timezone })) return;
+  const key = cronProviderMinuteKey(now, target.timezone);
+  for (const existing of fired) {
+    if (!existing.startsWith(`${key.dayKey}:`)) fired.delete(existing);
+  }
+  if (fired.has(key.minuteKey)) return;
+  fired.add(key.minuteKey);
+  const host = target.host?.(now) ?? {
+    iso: now.toISOString(),
+    timestamp_ms: now.getTime(),
+    timestamp_ns: (BigInt(now.getTime()) * 1000000n).toString(),
+    timezone: target.timezone
+  };
+  for (const binding of cronBindings(target)) {
+    binding.boundary.emit(host, bindingEmitOptions(host, binding, void 0));
+  }
+}
+function cronProviderMinuteKey(date, timezone) {
+  if (timezone === void 0) {
+    const dayKey2 = `${date.getFullYear()}-${date.getMonth() + 1}-${date.getDate()}`;
+    return { dayKey: dayKey2, minuteKey: `${dayKey2}:${date.getHours()}:${date.getMinutes()}` };
+  }
+  const parts = new Intl.DateTimeFormat("en-US-u-ca-gregory-nu-latn", {
+    timeZone: timezone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    hourCycle: "h23"
+  }).formatToParts(date);
+  const byType = new Map(parts.map((part) => [part.type, part.value]));
+  const dayKey = `${byType.get("year")}-${byType.get("month")}-${byType.get("day")}`;
+  return { dayKey, minuteKey: `${dayKey}:${byType.get("hour")}:${byType.get("minute")}` };
+}
+function lowerCaughtException(exception, host, opts) {
+  if (isDataIssue(exception)) return lowerHttpReplyPayload(exception, host, opts);
+  return (opts.protocolError ?? protocolError)(exception, host);
+}
+function guardDecisionResponse(decision, host, opts) {
+  if (decision.issue !== void 0) return lowerHttpReplyPayload(decision.issue, host, opts);
+  if (Number.isInteger(decision.status)) {
+    return {
+      status: decision.status,
+      body: decision.body ?? {
+        code: "graphrefly.guard_denied",
+        message: decision.reason ?? "GraphReFly guard denied request"
+      },
+      headers: decision.headers
+    };
+  }
+  return {
+    status: 403,
+    body: {
+      code: "graphrefly.guard_denied",
+      message: decision.reason ?? "GraphReFly guard denied request"
+    },
+    headers: decision.headers
+  };
+}
+var GraphGuardDeniedException = class extends HttpException {
+  payload;
+  constructor(payload) {
+    super(payload.body ?? {}, payload.status);
+    this.payload = payload;
+  }
+};
+var GraphGuardProtocolErrorException = class extends HttpException {
+  constructor(payload) {
+    super(payload.body ?? {}, payload.status);
+  }
+};
+function isGraphGuardDeniedException(value) {
+  return value instanceof GraphGuardDeniedException;
+}
+var GraphGuardDeniedFilter = class {
+  catch(exception, host) {
+    if (!isGraphGuardDeniedException(exception)) throw exception;
+    return writeHttpResponse(host, exception.payload);
+  }
+};
+Catch(GraphGuardDeniedException)(GraphGuardDeniedFilter);
+function writeHttpResponse(host, payload) {
+  const response = host.switchToHttp?.().getResponse?.();
+  if (response === void 0) return payload;
+  for (const [name, value] of Object.entries(payload.headers ?? {})) {
+    if (typeof response.setHeader === "function") response.setHeader(name, value);
+    else response.header?.(name, value);
+  }
+  response.status?.(payload.status);
+  if (typeof response.json === "function") return response.json(payload.body ?? {});
+  if (typeof response.send === "function") return response.send(payload.body);
+  return payload;
+}
+export {
+  GRAPHREFLY_NEST_CRON_SCHEDULER,
+  GRAPHREFLY_NEST_EXCEPTION_FILTER,
+  GRAPHREFLY_NEST_LIFECYCLE_HOOKS,
+  GraphExceptionFilterBridge,
+  GraphGuardDeniedException,
+  GraphGuardDeniedFilter,
+  createGraphCronController,
+  createGraphExceptionFilter,
+  createGraphGuardDeniedFilter,
+  graphCronTarget,
+  graphLifecycleTarget,
+  isGraphGuardDeniedException,
+  provideGraphBoundaryInterceptor,
+  provideGraphCronScheduler,
+  provideGraphExceptionFilter,
+  provideGraphGuard,
+  provideGraphGuardDeniedFilter,
+  provideGraphLifecycleHooks,
+  provideGraphNativeHttpProviders,
+  provideGraphNativeProviders
+};
+//# sourceMappingURL=native.js.map