@getcronit/pylon 2.9.3-canary-20250205110448.8418d96f70fc097b9339fc5224745875bc9b4748 → 2.9.3-canary-20250205112941.f25b5eb354aed2fceb39bcc739d912365da8077b

package/dist/index.js

@@ -1,4 +1,249 @@
-var F=(e=>typeof require<"u"?require:typeof Proxy<"u"?new Proxy(e,{get:(t,o)=>(typeof require<"u"?require:t)[o]}):e)(function(e){if(typeof require<"u")return require.apply(this,arguments);throw Error('Dynamic require of "'+e+'" is not supported')});import*as k from"@sentry/bun";import te from"consola";import{GraphQLError as ne}from"graphql";import{AsyncLocalStorage as W}from"async_hooks";import{sendFunctionEvent as Z}from"@getcronit/pylon-telemetry";import{env as X}from"hono/adapter";var w=new W,Q=()=>{let e=Date.now(),t=w.getStore();if(Z({name:"getContext",duration:Date.now()-e}).then(()=>{}),!t)throw new Error("Context not defined");return t.env=X(t),t},ee=e=>w.enterWith(e);import{isAsyncIterable as re}from"graphql-yoga";function oe(e){let t=new Set,o=e;for(;o&&o!==Object.prototype;)Object.getOwnPropertyNames(o).forEach(r=>t.add(r)),o=Object.getPrototypeOf(o);return Array.from(t).filter(n=>n!=="constructor")}async function A(e,t,o=null,n=[],r){if(e===null||e instanceof Date)return e;if(Array.isArray(e))return await Promise.all(e.map(async i=>await A(i,t,o,n,r)));if(typeof e=="function")return k.startSpan({name:e.name,op:"pylon.fn"},async()=>await t.call(o,e,n,r));if(e instanceof Promise)return await A(await e,t,o,n,r);if(re(e))return e;if(typeof e=="object"){o=e;let i={};for(let s of oe(e))i[s]=await A(e[s],t,o,n,r);return i}else return await e}function L(e){return(t,o,n)=>{let r=arguments[1],i=arguments[2],s={};if(n){let x=n.parentType.getFields()[n.fieldName]?.args?.reduce((m,d)=>(t[d.name]!==void 0?m[d.name]=t[d.name]:m[d.name]=void 0,m),{});x&&(s=x)}else s=t;let h=Object.keys(s).map(u=>s[u]),p=this||{};return A(e.call(p,...h),L,this,r,i)}}var M=(e,t)=>{let o=r=>async(i,s,h,p)=>k.withScope(async c=>{let u=w.getStore();u||te.warn("Context is not defined. Make sure AsyncLocalStorage is supported in your environment."),u?.set("graphqlResolveInfo",p);let a=u?.get("auth");a?.active&&c.setUser({id:a.sub,username:a.preferred_username,email:a.email,details:a});let l=null;switch(p.operation.operation){case"query":l=p.schema.getQueryType();break;case"mutation":l=p.schema.getMutationType();break;case"subscription":l=p.schema.getSubscriptionType();break;default:throw new Error("Unknown operation")}let d=(l?.getFields()[p.fieldName]?.args||[]).reduce((f,b)=>(s[b.name]!==void 0?f[b.name]=s[b.name]:f[b.name]=void 0,f),{}),R=await r,g=[];for(let f of p.operation.selectionSet.selections)f.kind==="Field"&&f.name.value===p.fieldName&&(g=f.selectionSet?.selections||[]);let y=await A(R,L,void 0,g,p);return typeof y!="function"?y:await y(d)}),n={};for(let r of Object.keys(e.Query))e.Query[r]||delete e.Query[r];if(e.Query&&Object.keys(e.Query).length>0)for(let[r,i]of Object.entries(e.Query))n.Query||(n.Query={}),n.Query[r]=o(i);if(e.Mutation&&Object.keys(e.Mutation).length>0){n.Mutation||(n.Mutation={});for(let[r,i]of Object.entries(e.Mutation))n.Mutation[r]=o(i)}if(e.Subscription&&Object.keys(e.Subscription).length>0){n.Subscription||(n.Subscription={});for(let[r,i]of Object.entries(e.Subscription))n.Subscription[r]={subscribe:o(i),resolve:s=>s}}if(!n.Query)throw new Error(`At least one 'Query' resolver must be provided.
+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/define-pylon.ts
+import * as Sentry from "@sentry/bun";
+import consola from "consola";
+import {
+  GraphQLError
+} from "graphql";
+
+// src/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { sendFunctionEvent } from "@getcronit/pylon-telemetry";
+import { env } from "hono/adapter";
+var asyncContext = new AsyncLocalStorage();
+var getContext = () => {
+  const start = Date.now();
+  const ctx = asyncContext.getStore();
+  sendFunctionEvent({
+    name: "getContext",
+    duration: Date.now() - start
+  }).then(() => {
+  });
+  if (!ctx) {
+    throw new Error("Context not defined");
+  }
+  ctx.env = env(ctx);
+  return ctx;
+};
+var setContext = (context) => {
+  return asyncContext.enterWith(context);
+};
+
+// src/define-pylon.ts
+import { isAsyncIterable } from "graphql-yoga";
+function getAllPropertyNames(instance) {
+  const allProps = /* @__PURE__ */ new Set();
+  let currentObj = instance;
+  while (currentObj && currentObj !== Object.prototype) {
+    const ownProps = Object.getOwnPropertyNames(currentObj);
+    ownProps.forEach((prop) => allProps.add(prop));
+    currentObj = Object.getPrototypeOf(currentObj);
+  }
+  return Array.from(allProps).filter((prop) => prop !== "constructor");
+}
+async function wrapFunctionsRecursively(obj, wrapper, that = null, selectionSet = [], info) {
+  if (obj === null || obj instanceof Date) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    return await Promise.all(
+      obj.map(async (item) => {
+        return await wrapFunctionsRecursively(
+          item,
+          wrapper,
+          that,
+          selectionSet,
+          info
+        );
+      })
+    );
+  } else if (typeof obj === "function") {
+    return Sentry.startSpan(
+      {
+        name: obj.name,
+        op: "pylon.fn"
+      },
+      async () => {
+        return await wrapper.call(that, obj, selectionSet, info);
+      }
+    );
+  } else if (obj instanceof Promise) {
+    return await wrapFunctionsRecursively(
+      await obj,
+      wrapper,
+      that,
+      selectionSet,
+      info
+    );
+  } else if (isAsyncIterable(obj)) {
+    return obj;
+  } else if (typeof obj === "object") {
+    that = obj;
+    const result = {};
+    for (const key of getAllPropertyNames(obj)) {
+      result[key] = await wrapFunctionsRecursively(
+        obj[key],
+        wrapper,
+        that,
+        selectionSet,
+        info
+      );
+    }
+    return result;
+  } else {
+    return await obj;
+  }
+}
+function spreadFunctionArguments(fn) {
+  return (otherArgs, c, info) => {
+    const selections = arguments[1];
+    const realInfo = arguments[2];
+    let args = {};
+    if (info) {
+      const type = info.parentType;
+      const field = type.getFields()[info.fieldName];
+      const fieldArguments = field?.args;
+      const preparedArguments = fieldArguments?.reduce(
+        (acc, arg) => {
+          if (otherArgs[arg.name] !== void 0) {
+            acc[arg.name] = otherArgs[arg.name];
+          } else {
+            acc[arg.name] = void 0;
+          }
+          return acc;
+        },
+        {}
+      );
+      if (preparedArguments) {
+        args = preparedArguments;
+      }
+    } else {
+      args = otherArgs;
+    }
+    const orderedArgs = Object.keys(args).map((key) => args[key]);
+    const that = this || {};
+    const result = wrapFunctionsRecursively(
+      fn.call(that, ...orderedArgs),
+      spreadFunctionArguments,
+      this,
+      selections,
+      realInfo
+    );
+    return result;
+  };
+}
+var resolversToGraphQLResolvers = (resolvers, configureContext) => {
+  const rootGraphqlResolver = (fn) => async (_, args, ctx, info) => {
+    return Sentry.withScope(async (scope) => {
+      const ctx2 = asyncContext.getStore();
+      if (!ctx2) {
+        consola.warn(
+          "Context is not defined. Make sure AsyncLocalStorage is supported in your environment."
+        );
+      }
+      ctx2?.set("graphqlResolveInfo", info);
+      const auth2 = ctx2?.get("auth");
+      if (auth2?.active) {
+        scope.setUser({
+          id: auth2.sub,
+          username: auth2.preferred_username,
+          email: auth2.email,
+          details: auth2
+        });
+      }
+      let type = null;
+      switch (info.operation.operation) {
+        case "query":
+          type = info.schema.getQueryType();
+          break;
+        case "mutation":
+          type = info.schema.getMutationType();
+          break;
+        case "subscription":
+          type = info.schema.getSubscriptionType();
+          break;
+        default:
+          throw new Error("Unknown operation");
+      }
+      const field = type?.getFields()[info.fieldName];
+      const fieldArguments = field?.args || [];
+      const preparedArguments = fieldArguments.reduce(
+        (acc, arg) => {
+          if (args[arg.name] !== void 0) {
+            acc[arg.name] = args[arg.name];
+          } else {
+            acc[arg.name] = void 0;
+          }
+          return acc;
+        },
+        {}
+      );
+      let inner = await fn;
+      let baseSelectionSet = [];
+      for (const selection of info.operation.selectionSet.selections) {
+        if (selection.kind === "Field" && selection.name.value === info.fieldName) {
+          baseSelectionSet = selection.selectionSet?.selections || [];
+        }
+      }
+      const wrappedFn = await wrapFunctionsRecursively(
+        inner,
+        spreadFunctionArguments,
+        void 0,
+        baseSelectionSet,
+        info
+      );
+      if (typeof wrappedFn !== "function") {
+        return wrappedFn;
+      }
+      const res = await wrappedFn(preparedArguments);
+      return res;
+    });
+  };
+  const graphqlResolvers = {};
+  for (const key of Object.keys(resolvers.Query)) {
+    if (!resolvers.Query[key]) {
+      delete resolvers.Query[key];
+    }
+  }
+  if (resolvers.Query && Object.keys(resolvers.Query).length > 0) {
+    for (const [key, value] of Object.entries(resolvers.Query)) {
+      if (!graphqlResolvers.Query) {
+        graphqlResolvers.Query = {};
+      }
+      graphqlResolvers.Query[key] = rootGraphqlResolver(
+        value
+      );
+    }
+  }
+  if (resolvers.Mutation && Object.keys(resolvers.Mutation).length > 0) {
+    if (!graphqlResolvers.Mutation) {
+      graphqlResolvers.Mutation = {};
+    }
+    for (const [key, value] of Object.entries(resolvers.Mutation)) {
+      graphqlResolvers.Mutation[key] = rootGraphqlResolver(
+        value
+      );
+    }
+  }
+  if (resolvers.Subscription && Object.keys(resolvers.Subscription).length > 0) {
+    if (!graphqlResolvers.Subscription) {
+      graphqlResolvers.Subscription = {};
+    }
+    for (const [key, value] of Object.entries(resolvers.Subscription)) {
+      graphqlResolvers.Subscription[key] = {
+        subscribe: rootGraphqlResolver(value),
+        resolve: (payload) => payload
+      };
+    }
+  }
+  if (!graphqlResolvers.Query) {
+    throw new Error(`At least one 'Query' resolver must be provided.
 
 Example:
 
@@ -8,7 +253,343 @@ export const graphql = {
     hello: () => 'world'
   }
 }
-`);for(let r of Object.keys(e))r!=="Query"&&r!=="Mutation"&&r!=="Subscription"&&(n[r]=e[r]);return n},C=class extends ne{extensions;constructor(t,o,n){super(t,{originalError:n}),this.extensions=o,this.cause=n}};import ue from"jsonwebtoken";import pe from"path";import{HTTPException as V}from"hono/http-exception";import{env as N}from"hono/adapter";import*as q from"@sentry/bun";import{existsSync as le,readFileSync as de}from"fs";import{sendFunctionEvent as _}from"@getcronit/pylon-telemetry";import{sendFunctionEvent as ie}from"@getcronit/pylon-telemetry";import{HTTPException as se}from"hono/http-exception";import{sendFunctionEvent as ae}from"@getcronit/pylon-telemetry";function j(e){ae({name:"createDecorator",duration:0}).then(()=>{});function t(o,n,r){if(r){let i=r.value;return r.value=async function(...s){return await e(...s),i.apply(this,s)},r}else if(!r){if(n===void 0){let s=o;return async function(...h){return await e(...h),s(...h)}}let i=o[n];Object.defineProperty(o,n,{get:function(){return async function(...s){return await e(...s),typeof i=="function"?i(...s):i}},set:function(s){i=s},enumerable:!0,configurable:!0});return}}return t}function ce(e){ie({name:"requireAuth",duration:0}).then(()=>{});let t=async o=>{let n=await o;try{await U.require(e)(n,async()=>{})}catch(r){if(r instanceof se){if(r.status===401)throw new C(r.message,{statusCode:401,code:"AUTH_REQUIRED"});if(r.status===403){let i=r.getResponse();throw new C(i.statusText,{statusCode:i.status,code:"AUTHORIZATION_REQUIRED",details:{missingRoles:i.headers.get("Missing-Roles")?.split(","),obtainedRoles:i.headers.get("Obtained-Roles")?.split(",")}})}else throw r}throw r}};return j(async()=>{let o=Q();await t(o)})}var me=()=>{let e=pe.join(process.cwd(),"key.json"),t;if(le(e))try{t=JSON.parse(de(e,"utf-8"))}catch{throw new Error("Error while reading key file. Make sure it is valid JSON")}let o=q.startSpan({name:"AuthMiddleware",op:"auth"},()=>async function(n,r){let i=N(n).AUTH_ISSUER;if(!i)throw new Error("AUTH_ISSUER is not set");if(!t){let a=N(n).AUTH_KEY;t=a?JSON.parse(a):void 0}if(!t)throw new Error("You have initialized the auth middleware without a private key file");let s=N(n).AUTH_PROJECT_ID,h=`${i}/oauth/v2/introspect`;async function p(a){let d=((await(await fetch(`${i}/auth/v1/usergrants/me/_search`,{method:"POST",headers:{"Content-Type":"application/json",Authorization:`Bearer ${a}`}})).json()).result?.map(g=>(g.roles||[]).map(y=>`${g.projectId}:${y}`))||[]).flat(),R=new Set(d);if(s)for(let g of d){let[y,...T]=g.split(":"),f=T.join(":");y===s&&R.add(f)}return Array.from(R)}async function c(a){if(!t)throw new Error("Internal error: API_PRIVATE_KEY_FILE is not set");let l={iss:t.clientId,sub:t.clientId,aud:i,exp:Math.floor(Date.now()/1e3)+60*60,iat:Math.floor(Date.now()/1e3)},x={alg:"RS256",kid:t.keyId},m=ue.sign(l,t.key,{algorithm:"RS256",header:x}),d=new Set;d.add("openid"),d.add("profile"),d.add("email"),s&&d.add(`urn:zitadel:iam:org:project:id:${s}:aud`);let R=Array.from(d).join(" "),g=new URLSearchParams({client_assertion_type:"urn:ietf:params:oauth:client-assertion-type:jwt-bearer",client_assertion:m,token:a,scope:R}).toString();try{let y=await fetch(h,{method:"POST",headers:{"Content-Type":"application/x-www-form-urlencoded"},body:g});if(!y.ok)throw new Error("Network response was not ok");let T=await y.json(),f=await p(a);return{...T,roles:f}}catch(y){throw console.error("Error while introspecting token",y),new Error("Token introspection failed")}}let u;if(n.req.header("Authorization")){let a=n.req.header("Authorization");if(a){let l=a.split(" ");l.length===2&&l[0]==="Bearer"&&(u=l[1])}}if(!u){let a=n.req.query("token");a&&(u=a)}if(u){let a=await c(u);a.active&&(n.set("auth",a),q.setUser({id:a.sub,username:a.preferred_username,email:a.email,details:a}))}return r()});return _({name:"authInitialize",duration:0}).then(()=>{}),o},fe=(e={})=>{_({name:"authRequire",duration:0}).then(()=>{});let t=async(o,n)=>{let r=N(o).AUTH_PROJECT_ID,i=o.get("auth");if(!i)throw new V(401,{message:"Authentication required"});if(e.roles){let s=i.roles;if(!e.roles.some(p=>s.includes(p)||s.includes(`${r}:${p}`))){let p=new Response("Forbidden",{status:403,statusText:"Forbidden",headers:{"Missing-Roles":e.roles.join(","),"Obtained-Roles":s.join(",")}});throw new V(p.status,{res:p})}}return n()};return _({name:"authRequire",duration:0}).then(()=>{}),t},U={initialize:me,require:fe};import{Hono as he}from"hono";import{logger as ge}from"hono/logger";import{sentry as xe}from"@hono/sentry";import{html as ye}from"hono/html";var G=async(e,t)=>e.html(ye`
+`);
+  }
+  for (const key of Object.keys(resolvers)) {
+    if (key !== "Query" && key !== "Mutation" && key !== "Subscription") {
+      graphqlResolvers[key] = resolvers[key];
+    }
+  }
+  return graphqlResolvers;
+};
+var ServiceError = class extends GraphQLError {
+  extensions;
+  constructor(message, extensions, error) {
+    super(message, {
+      originalError: error
+    });
+    this.extensions = extensions;
+    this.cause = error;
+  }
+};
+
+// src/auth/index.ts
+import jwt from "jsonwebtoken";
+import path from "path";
+import { HTTPException as HTTPException2 } from "hono/http-exception";
+import { env as env2 } from "hono/adapter";
+import * as Sentry2 from "@sentry/bun";
+import { existsSync, readFileSync } from "fs";
+import { sendFunctionEvent as sendFunctionEvent4 } from "@getcronit/pylon-telemetry";
+
+// src/auth/decorators/requireAuth.ts
+import { sendFunctionEvent as sendFunctionEvent3 } from "@getcronit/pylon-telemetry";
+import { HTTPException } from "hono/http-exception";
+
+// src/create-decorator.ts
+import { sendFunctionEvent as sendFunctionEvent2 } from "@getcronit/pylon-telemetry";
+function createDecorator(callback) {
+  sendFunctionEvent2({
+    name: "createDecorator",
+    duration: 0
+  }).then(() => {
+  });
+  function MyDecorator(arg1, propertyKey, descriptor) {
+    if (descriptor) {
+      const originalMethod = descriptor.value;
+      descriptor.value = async function(...args) {
+        await callback(...args);
+        return originalMethod.apply(this, args);
+      };
+      return descriptor;
+    } else {
+      if (!descriptor) {
+        if (propertyKey === void 0) {
+          const originalFunction = arg1;
+          return async function(...args) {
+            await callback(...args);
+            return originalFunction(...args);
+          };
+        }
+        let value = arg1[propertyKey];
+        Object.defineProperty(arg1, propertyKey, {
+          get: function() {
+            return async function(...args) {
+              await callback(...args);
+              if (typeof value === "function") {
+                return value(...args);
+              }
+              return value;
+            };
+          },
+          set: function(newValue) {
+            value = newValue;
+          },
+          enumerable: true,
+          configurable: true
+        });
+        return;
+      }
+    }
+  }
+  return MyDecorator;
+}
+
+// src/auth/decorators/requireAuth.ts
+function requireAuth(checks) {
+  sendFunctionEvent3({
+    name: "requireAuth",
+    duration: 0
+  }).then(() => {
+  });
+  const checkAuth = async (c) => {
+    const ctx = await c;
+    try {
+      await auth.require(checks)(ctx, async () => {
+      });
+    } catch (e) {
+      if (e instanceof HTTPException) {
+        if (e.status === 401) {
+          throw new ServiceError(e.message, {
+            statusCode: 401,
+            code: "AUTH_REQUIRED"
+          });
+        } else if (e.status === 403) {
+          const res = e.getResponse();
+          throw new ServiceError(res.statusText, {
+            statusCode: res.status,
+            code: "AUTHORIZATION_REQUIRED",
+            details: {
+              missingRoles: res.headers.get("Missing-Roles")?.split(","),
+              obtainedRoles: res.headers.get("Obtained-Roles")?.split(",")
+            }
+          });
+        } else {
+          throw e;
+        }
+      }
+      throw e;
+    }
+  };
+  return createDecorator(async () => {
+    const ctx = getContext();
+    await checkAuth(ctx);
+  });
+}
+
+// src/auth/index.ts
+var authInitialize = () => {
+  const authKeyFilePath = path.join(process.cwd(), "key.json");
+  let API_PRIVATE_KEY_FILE = void 0;
+  if (existsSync(authKeyFilePath)) {
+    try {
+      API_PRIVATE_KEY_FILE = JSON.parse(readFileSync(authKeyFilePath, "utf-8"));
+    } catch (error) {
+      throw new Error(
+        "Error while reading key file. Make sure it is valid JSON"
+      );
+    }
+  }
+  const middleware = Sentry2.startSpan(
+    {
+      name: "AuthMiddleware",
+      op: "auth"
+    },
+    () => async function(ctx, next) {
+      const AUTH_ISSUER = env2(ctx).AUTH_ISSUER;
+      if (!AUTH_ISSUER) {
+        throw new Error("AUTH_ISSUER is not set");
+      }
+      if (!API_PRIVATE_KEY_FILE) {
+        const AUTH_KEY = env2(ctx).AUTH_KEY;
+        API_PRIVATE_KEY_FILE = AUTH_KEY ? JSON.parse(AUTH_KEY) : void 0;
+      }
+      if (!API_PRIVATE_KEY_FILE) {
+        throw new Error(
+          "You have initialized the auth middleware without a private key file"
+        );
+      }
+      const AUTH_PROJECT_ID = env2(ctx).AUTH_PROJECT_ID;
+      const ZITADEL_INTROSPECTION_URL = `${AUTH_ISSUER}/oauth/v2/introspect`;
+      async function getRolesFromToken(tokenString) {
+        const response = await fetch(
+          `${AUTH_ISSUER}/auth/v1/usergrants/me/_search`,
+          {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+              Authorization: `Bearer ${tokenString}`
+            }
+          }
+        );
+        const data = await response.json();
+        const userRoles = data.result?.map((grant) => {
+          return (grant.roles || []).map((role) => {
+            return `${grant.projectId}:${role}`;
+          });
+        }) || [];
+        const projectScopedRoles = userRoles.flat();
+        const rolesSet = new Set(projectScopedRoles);
+        if (AUTH_PROJECT_ID) {
+          for (const role of projectScopedRoles) {
+            const [projectId, ...roleNameParts] = role.split(":");
+            const roleName = roleNameParts.join(":");
+            if (projectId === AUTH_PROJECT_ID) {
+              rolesSet.add(roleName);
+            }
+          }
+        }
+        return Array.from(rolesSet);
+      }
+      async function introspectToken(tokenString) {
+        if (!API_PRIVATE_KEY_FILE) {
+          throw new Error("Internal error: API_PRIVATE_KEY_FILE is not set");
+        }
+        const payload = {
+          iss: API_PRIVATE_KEY_FILE.clientId,
+          sub: API_PRIVATE_KEY_FILE.clientId,
+          aud: AUTH_ISSUER,
+          exp: Math.floor(Date.now() / 1e3) + 60 * 60,
+          // Expires in 1 hour
+          iat: Math.floor(Date.now() / 1e3)
+        };
+        const headers = {
+          alg: "RS256",
+          kid: API_PRIVATE_KEY_FILE.keyId
+        };
+        const jwtToken = jwt.sign(payload, API_PRIVATE_KEY_FILE.key, {
+          algorithm: "RS256",
+          header: headers
+        });
+        const scopeSet = /* @__PURE__ */ new Set();
+        scopeSet.add("openid");
+        scopeSet.add("profile");
+        scopeSet.add("email");
+        if (AUTH_PROJECT_ID) {
+          scopeSet.add(
+            `urn:zitadel:iam:org:project:id:${AUTH_PROJECT_ID}:aud`
+          );
+        }
+        const scope = Array.from(scopeSet).join(" ");
+        const body = new URLSearchParams({
+          client_assertion_type: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
+          client_assertion: jwtToken,
+          token: tokenString,
+          scope
+        }).toString();
+        try {
+          const response = await fetch(ZITADEL_INTROSPECTION_URL, {
+            method: "POST",
+            headers: { "Content-Type": "application/x-www-form-urlencoded" },
+            body
+          });
+          if (!response.ok) {
+            throw new Error("Network response was not ok");
+          }
+          const tokenData = await response.json();
+          const roles = await getRolesFromToken(tokenString);
+          const state = {
+            ...tokenData,
+            roles
+          };
+          return state;
+        } catch (error) {
+          console.error("Error while introspecting token", error);
+          throw new Error("Token introspection failed");
+        }
+      }
+      let token = void 0;
+      if (ctx.req.header("Authorization")) {
+        const authHeader = ctx.req.header("Authorization");
+        if (authHeader) {
+          const parts = authHeader.split(" ");
+          if (parts.length === 2 && parts[0] === "Bearer") {
+            token = parts[1];
+          }
+        }
+      }
+      if (!token) {
+        const queryToken = ctx.req.query("token");
+        if (queryToken) {
+          token = queryToken;
+        }
+      }
+      if (token) {
+        const auth2 = await introspectToken(token);
+        if (auth2.active) {
+          ctx.set("auth", auth2);
+          Sentry2.setUser({
+            id: auth2.sub,
+            username: auth2.preferred_username,
+            email: auth2.email,
+            details: auth2
+          });
+        }
+      }
+      return next();
+    }
+  );
+  sendFunctionEvent4({
+    name: "authInitialize",
+    duration: 0
+  }).then(() => {
+  });
+  return middleware;
+};
+var authRequire = (checks = {}) => {
+  sendFunctionEvent4({
+    name: "authRequire",
+    duration: 0
+  }).then(() => {
+  });
+  const middleware = async (ctx, next) => {
+    const AUTH_PROJECT_ID = env2(ctx).AUTH_PROJECT_ID;
+    const auth2 = ctx.get("auth");
+    if (!auth2) {
+      throw new HTTPException2(401, {
+        message: "Authentication required"
+      });
+    }
+    if (checks.roles) {
+      const roles = auth2.roles;
+      const hasRole = checks.roles.some((role) => {
+        return roles.includes(role) || roles.includes(`${AUTH_PROJECT_ID}:${role}`);
+      });
+      if (!hasRole) {
+        const resError = new Response("Forbidden", {
+          status: 403,
+          statusText: "Forbidden",
+          headers: {
+            "Missing-Roles": checks.roles.join(","),
+            "Obtained-Roles": roles.join(",")
+          }
+        });
+        throw new HTTPException2(resError.status, { res: resError });
+      }
+    }
+    return next();
+  };
+  sendFunctionEvent4({
+    name: "authRequire",
+    duration: 0
+  }).then(() => {
+  });
+  return middleware;
+};
+var auth = {
+  initialize: authInitialize,
+  require: authRequire
+};
+
+// src/app/index.ts
+import { Hono } from "hono";
+import { logger } from "hono/logger";
+import { sentry } from "@hono/sentry";
+
+// src/app/handler/graphql-viewer-handler.ts
+import { html } from "hono/html";
+var graphqlViewerHandler = async (c, next) => {
+  return c.html(html`
     <!DOCTYPE html>
     <html>
       <head>
@@ -66,5 +647,293 @@ export const graphql = {
         </script>
       </body>
     </html>
-  `);var P=new he;P.use("*",xe());P.use("*",async(e,t)=>new Promise((o,n)=>{w.run(e,async()=>{try{o(await t())}catch(r){n(r)}})}));P.use("*",ge());P.use((e,t)=>(e.req.id=crypto.randomUUID(),t()));P.get("/viewer",G);import{createSchema as ve,createYoga as Ce}from"graphql-yoga";import{GraphQLScalarType as Pe,Kind as K}from"graphql";import{DateTimeISOResolver as Oe,GraphQLVoid as Ae,JSONObjectResolver as Ie,JSONResolver as ke}from"graphql-scalars";import{Kind as we,print as Se}from"graphql";import{getDocumentString as Ee,handleStreamOrSingleExecutionResult as Re,isOriginalGraphQLError as Te}from"@envelop/core";import*as E from"@sentry/node";var be=Te,J=(e={})=>{function t(u,a){return e[u]??a}let o=t("startTransaction",!0),n=t("includeRawResult",!1),r=t("includeExecuteVariables",!1),i=t("renameTransaction",!1),s=t("skip",()=>!1),h=t("skipError",be),p=e.eventIdKey===null?null:"sentryEventId";function c(u,a){return p!==null&&a!==null&&(u.extensions[p]=a),u}return{onExecute({args:u}){if(s(u))return;let a=u.document.definitions.find(f=>f.kind===we.OPERATION_DEFINITION),l=a.operation,x=Ee(u.document,Se),m=u.operationName||a.name?.value||"Anonymous Operation",d=e.appendTags&&e.appendTags(u)||{},R=e.traceparentData&&e.traceparentData(u)||{},g=e.transactionName?e.transactionName(u):m,y=e.operationName?e.operationName(u):"execute",T={operationName:m,operation:l,...d};return e.configureScope&&e.configureScope(u,E.getCurrentScope()),{onExecuteDone(f){return Re(f,({result:v,setResult:Y})=>{E.startSpanManual({op:y,name:m,attributes:T},I=>{i&&I.updateName(g),I.setAttribute("document",x),n&&I.setAttribute("result",JSON.stringify(v)),v.errors&&v.errors.length>0&&E.withScope(S=>{S.setTransactionName(m),S.setTag("operation",l),S.setTag("operationName",m),S.setExtra("document",x),S.setTags(d||{}),n&&S.setExtra("result",v),r&&S.setExtra("variables",u.variableValues);let z=v.errors?.map(O=>{if(h(O)===!0)return O;let D=(O.path??[]).map(H=>typeof H=="number"?"$index":H).join(" > ");D&&S.addBreadcrumb({category:"execution-path",message:D,level:"debug"});let B=E.captureException(O.originalError,{fingerprint:["graphql",D,m,l],contexts:{GraphQL:{operationName:m,operationType:l,variables:u.variableValues}}});return c(O,B)});Y({...v,errors:z})}),I.end()})})}}}}};import{readFileSync as Ne}from"fs";import $ from"path";var qe=e=>{let{typeDefs:t,resolvers:o,graphql:n,config:r}=e;if(!t){let c=$.join(process.cwd(),".pylon","schema.graphql");c&&(t=Ne(c,"utf-8"))}if(!t)throw new Error("No schema provided.");if(!o){let c=$.join(process.cwd(),".pylon","resolvers.js");c&&(o=F(c).resolvers)}let i=M(n),s=ve({typeDefs:t,resolvers:{...i,...o,Date:Oe,JSON:ke,Object:Ie,Void:Ae,Number:new Pe({name:"Number",description:"Custom scalar that handles both integers and floats",parseValue(c){if(typeof c!="number")throw new TypeError(`Value is not a number: ${c}`);return c},parseLiteral(c){if(c.kind===K.INT||c.kind===K.FLOAT)return parseFloat(c.value);throw new TypeError(`Value is not a valid number or float: ${"value"in c?c.value:c}`)},serialize(c){if(typeof c!="number")throw new TypeError(`Value is not a number: ${c}`);return c}})}}),h=Ce({landingPage:!1,graphiql:c=>({shouldPersistHeaders:!0,title:"Pylon Playground",defaultQuery:"# Welcome to the Pylon Playground!"}),graphqlEndpoint:"/graphql",...r,plugins:[J(),...r?.plugins||[]],schema:s});return async c=>{let u={};try{u=c.executionCtx}catch{}let a=await h.fetch(c.req.raw,c.env,u);return c.newResponse(a.body,a)}};import{sendFunctionEvent as De}from"@getcronit/pylon-telemetry";function Qe(){let e=Date.now(),t=arguments[0]===!0;try{return w.getStore().env||process.env||{}}catch{return process.env}finally{t||De({name:"getEnv",duration:Date.now()-e}).then(()=>{})}}import{createPubSub as an}from"graphql-yoga";export{C as ServiceError,P as app,w as asyncContext,U as auth,j as createDecorator,an as experimentalCreatePubSub,Q as getContext,Qe as getEnv,qe as handler,ce as requireAuth,ee as setContext};
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../src/define-pylon.ts", "../src/context.ts", "../src/auth/index.ts", "../src/auth/decorators/requireAuth.ts", "../src/create-decorator.ts", "../src/app/index.ts", "../src/app/handler/graphql-viewer-handler.ts", "../src/app/handler/pylon-handler.ts", "../src/app/envelop/use-sentry.ts", "../src/get-env.ts", "../src/index.ts"],
  "sourcesContent": ["import * as Sentry from '@sentry/bun'\nimport consola from 'consola'\nimport {\n  FragmentDefinitionNode,\n  GraphQLError,\n  GraphQLErrorExtensions,\n  GraphQLObjectType,\n  GraphQLResolveInfo,\n  SelectionSetNode\n} from 'graphql'\n\nimport {Context, asyncContext} from './context'\nimport {isAsyncIterable, Maybe} from 'graphql-yoga'\n\nexport interface Resolvers {\n  Query: Record<string, any>\n  Mutation?: Record<string, any>\n  Subscription?: Record<string, any>\n}\n\ntype FunctionWrapper = (fn: (...args: any[]) => any) => (...args: any[]) => any\n\nfunction getAllPropertyNames(instance: any): string[] {\n  const allProps = new Set<string>()\n\n  // Traverse the prototype chain\n  let currentObj: any = instance\n\n  while (currentObj && currentObj !== Object.prototype) {\n    // Get all own property names of the current object\n    const ownProps = Object.getOwnPropertyNames(currentObj)\n\n    // Add each property to the Set\n    ownProps.forEach(prop => allProps.add(prop))\n\n    // Move up the prototype chain\n    currentObj = Object.getPrototypeOf(currentObj)\n  }\n\n  // Convert Set to array and filter out the constructor if desired\n  return Array.from(allProps).filter(prop => prop !== 'constructor')\n}\n\nasync function wrapFunctionsRecursively(\n  obj: any,\n  wrapper: FunctionWrapper,\n  that: any = null,\n  selectionSet: SelectionSetNode['selections'] = [],\n  info: GraphQLResolveInfo\n): Promise<any> {\n  // Skip if the object is a Date object or any other special object.\n  // Those objects are then handled by custom resolvers.\n  if (obj === null || obj instanceof Date) {\n    return obj\n  }\n\n  if (Array.isArray(obj)) {\n    return await Promise.all(\n      obj.map(async item => {\n        return await wrapFunctionsRecursively(\n          item,\n          wrapper,\n          that,\n          selectionSet,\n          info\n        )\n      })\n    )\n  } else if (typeof obj === 'function') {\n    return Sentry.startSpan(\n      {\n        name: obj.name,\n        op: 'pylon.fn'\n      },\n      async () => {\n        // @ts-ignore\n        return await wrapper.call(that, obj, selectionSet, info)\n      }\n    )\n  } else if (obj instanceof Promise) {\n    return await wrapFunctionsRecursively(\n      await obj,\n      wrapper,\n      that,\n      selectionSet,\n      info\n    )\n  } else if (isAsyncIterable(obj)) {\n    return obj\n  } else if (typeof obj === 'object') {\n    that = obj\n\n    const result: Record<string, any> = {}\n\n    for (const key of getAllPropertyNames(obj)) {\n      result[key] = await wrapFunctionsRecursively(\n        obj[key],\n        wrapper,\n        that,\n        selectionSet,\n        info\n      )\n    }\n\n    return result\n  } else {\n    return await obj\n  }\n}\nfunction spreadFunctionArguments<T extends (...args: any[]) => any>(fn: T) {\n  return (otherArgs: Record<string, any>, c: any, info: GraphQLResolveInfo) => {\n    const selections = arguments[1] as SelectionSetNode['selections']\n    const realInfo = arguments[2] as GraphQLResolveInfo\n\n    let args: Record<string, any> = {}\n\n    if (info) {\n      const type = info.parentType\n\n      const field = type.getFields()[info.fieldName]\n\n      const fieldArguments = field?.args\n\n      const preparedArguments = fieldArguments?.reduce(\n        (acc: {[x: string]: undefined}, arg: {name: string | number}) => {\n          if (otherArgs[arg.name] !== undefined) {\n            acc[arg.name] = otherArgs[arg.name]\n          } else {\n            acc[arg.name] = undefined\n          }\n\n          return acc\n        },\n        {} as Record<string, any>\n      )\n\n      if (preparedArguments) {\n        args = preparedArguments\n      }\n    } else {\n      args = otherArgs\n    }\n\n    const orderedArgs = Object.keys(args).map(key => args[key])\n\n    const that = this || {}\n\n    const result = wrapFunctionsRecursively(\n      fn.call(that, ...orderedArgs),\n      spreadFunctionArguments,\n      this,\n      selections,\n      realInfo\n    )\n\n    return result as ReturnType<typeof fn>\n  }\n}\n\n/**\n * Converts a set of resolvers into a corresponding set of GraphQL resolvers.\n * @param resolvers The original resolvers.\n * @returns The converted GraphQL resolvers.\n */\nexport const resolversToGraphQLResolvers = (\n  resolvers: Resolvers,\n  configureContext?: (context: Context) => Context\n): Resolvers => {\n  // Define a root resolver function that maps a given resolver function or object to a GraphQL resolver.\n  const rootGraphqlResolver =\n    (fn: Function | object | Promise<Function> | Promise<object>) =>\n    async (\n      _: object,\n      args: Record<string, any>,\n      ctx: Context,\n      info: GraphQLResolveInfo\n    ) => {\n      return Sentry.withScope(async scope => {\n        const ctx = asyncContext.getStore()\n\n\n        if (!ctx) {\n          consola.warn(\n            'Context is not defined. Make sure AsyncLocalStorage is supported in your environment.'\n          )\n        }\n\n        ctx?.set(\"graphqlResolveInfo\", info)\n\n        const auth = ctx?.get('auth')\n\n        if (auth?.active) {\n          scope.setUser({\n            id: auth.sub,\n            username: auth.preferred_username,\n            email: auth.email,\n            details: auth\n          })\n        }\n\n        // get query or mutation field\n\n        let type: Maybe<GraphQLObjectType> | null = null\n\n        switch (info.operation.operation) {\n          case 'query':\n            type = info.schema.getQueryType()\n            break\n          case 'mutation':\n            type = info.schema.getMutationType()\n            break\n          case 'subscription':\n            type = info.schema.getSubscriptionType()\n            break\n          default:\n            throw new Error('Unknown operation')\n        }\n\n        const field = type?.getFields()[info.fieldName]\n\n        // Get the list of arguments expected by the current query field.\n        const fieldArguments = field?.args || []\n\n        // Prepare the arguments for the resolver function call by adding any missing arguments with an undefined value.\n        const preparedArguments = fieldArguments.reduce(\n          (acc: {[x: string]: undefined}, arg: {name: string | number}) => {\n            if (args[arg.name] !== undefined) {\n              acc[arg.name] = args[arg.name]\n            } else {\n              acc[arg.name] = undefined\n            }\n\n            return acc\n          },\n          {} as Record<string, any>\n        )\n\n        // Determine the resolver function to call (either the given function or the wrappedWithContext function if it exists).\n        let inner = await fn\n\n        let baseSelectionSet: SelectionSetNode['selections'] = []\n\n        // Find the selection set for the current field.\n        for (const selection of info.operation.selectionSet.selections) {\n          if (\n            selection.kind === 'Field' &&\n            selection.name.value === info.fieldName\n          ) {\n            baseSelectionSet = selection.selectionSet?.selections || []\n          }\n        }\n\n        // Wrap the resolver function with any required middleware.\n        const wrappedFn = await wrapFunctionsRecursively(\n          inner,\n          spreadFunctionArguments,\n          this,\n          baseSelectionSet,\n          info\n        )\n\n        // Call the resolver function with the prepared arguments.\n        if (typeof wrappedFn !== 'function') {\n          return wrappedFn\n        }\n\n        const res = await wrappedFn(preparedArguments)\n\n        return res\n      })\n    }\n\n  // Convert the Query and Mutation resolvers to GraphQL resolvers.\n  const graphqlResolvers = {} as Resolvers\n\n  // Remove empty resolvers\n  for (const key of Object.keys(resolvers.Query)) {\n    if (!resolvers.Query[key]) {\n      delete resolvers.Query[key]\n    }\n  }\n\n  if (resolvers.Query && Object.keys(resolvers.Query).length > 0) {\n    for (const [key, value] of Object.entries(resolvers.Query)) {\n      if (!graphqlResolvers.Query) {\n        graphqlResolvers.Query = {}\n      }\n\n      graphqlResolvers.Query[key] = rootGraphqlResolver(\n        value as Function | object\n      )\n    }\n  }\n\n  if (resolvers.Mutation && Object.keys(resolvers.Mutation).length > 0) {\n    if (!graphqlResolvers.Mutation) {\n      graphqlResolvers.Mutation = {}\n    }\n\n    for (const [key, value] of Object.entries(resolvers.Mutation)) {\n      graphqlResolvers.Mutation[key] = rootGraphqlResolver(\n        value as Function | object\n      )\n    }\n  }\n\n  if (\n    resolvers.Subscription &&\n    Object.keys(resolvers.Subscription).length > 0\n  ) {\n    if (!graphqlResolvers.Subscription) {\n      graphqlResolvers.Subscription = {}\n    }\n\n    for (const [key, value] of Object.entries(resolvers.Subscription)) {\n      graphqlResolvers.Subscription[key] = {\n        subscribe: rootGraphqlResolver(value as Function | object),\n        resolve: (payload: any) => payload\n      }\n    }\n  }\n\n  // Query root type must be provided.\n  if (!graphqlResolvers.Query) {\n    // Custom Error for Query root type must be provided.\n\n    throw new Error(`At least one 'Query' resolver must be provided.\n\nExample:\n\nexport const graphql = {\n  Query: {\n    // Define at least one query resolver here\n    hello: () => 'world'\n  }\n}\n`)\n  }\n\n  // Add extra resolvers (e.g. custom scalars) to the GraphQL resolvers.\n  for (const key of Object.keys(resolvers)) {\n    if (key !== 'Query' && key !== 'Mutation' && key !== 'Subscription') {\n      graphqlResolvers[key] = resolvers[key]\n    }\n  }\n\n  return graphqlResolvers\n}\n\nexport class ServiceError extends GraphQLError {\n  extensions: GraphQLErrorExtensions\n\n  constructor(\n    message: string,\n    extensions: {\n      code: string\n      statusCode: number\n      details?: Record<string, any>\n    },\n    error?: Error\n  ) {\n    super(message, {\n      originalError: error\n    })\n    this.extensions = extensions\n    this.cause = error\n  }\n}\n", "import {Context as HonoContext} from 'hono'\nimport type {Toucan} from 'toucan-js'\nimport {AuthState} from './auth'\nimport {AsyncLocalStorage} from 'async_hooks'\nimport {sendFunctionEvent} from '@getcronit/pylon-telemetry'\nimport {env} from 'hono/adapter'\nimport type { GraphQLResolveInfo } from 'graphql'\n\nexport interface Bindings {\n  NODE_ENV: string\n  AUTH_PROJECT_ID?: string\n  AUTH_KEY?: string\n  AUTH_ISSUER?: string\n}\n\nexport interface Variables {\n  auth: AuthState\n  sentry: Toucan\n  graphqlResolveInfo?: GraphQLResolveInfo\n}\n\nexport type Env = {\n  Bindings: Bindings\n  Variables: Variables\n}\n\nexport type Context = HonoContext<Env, string, {}>\n\nexport const asyncContext = new AsyncLocalStorage<Context>()\n\nexport const getContext = () => {\n  const start = Date.now()\n  const ctx = asyncContext.getStore()\n\n  sendFunctionEvent({\n    name: 'getContext',\n    duration: Date.now() - start\n  }).then(() => {})\n\n  if (!ctx) {\n    throw new Error('Context not defined')\n  }\n\n  ctx.env = env(ctx)\n\n  return ctx\n}\n\nexport const setContext = (context: Context) => {\n  return asyncContext.enterWith(context)\n}\n", "import {MiddlewareHandler} from 'hono'\nimport jwt from 'jsonwebtoken'\nimport type {IdTokenClaims, IntrospectionResponse} from 'openid-client'\nimport path from 'path'\nimport {HTTPException} from 'hono/http-exception'\nimport {ContentfulStatusCode} from 'hono/utils/http-status'\nimport {env} from 'hono/adapter'\nimport * as Sentry from '@sentry/bun'\nimport {existsSync, readFileSync} from 'fs'\nimport {sendFunctionEvent} from '@getcronit/pylon-telemetry'\n\nexport type AuthState = IntrospectionResponse &\n  IdTokenClaims & {\n    roles: string[]\n  }\n\nconst authInitialize = () => {\n  // Load private key file from cwd\n  const authKeyFilePath = path.join(process.cwd(), 'key.json')\n\n  // Load private key file from cwd\n  let API_PRIVATE_KEY_FILE:\n    | {\n        type: 'application'\n        keyId: string\n        key: string\n        appId: string\n        clientId: string\n      }\n    | undefined = undefined\n\n  if (existsSync(authKeyFilePath)) {\n    try {\n      API_PRIVATE_KEY_FILE = JSON.parse(readFileSync(authKeyFilePath, 'utf-8'))\n    } catch (error) {\n      throw new Error(\n        'Error while reading key file. Make sure it is valid JSON'\n      )\n    }\n  }\n\n  const middleware: MiddlewareHandler<{\n    Variables: {\n      auth: AuthState\n    }\n  }> = Sentry.startSpan(\n    {\n      name: 'AuthMiddleware',\n      op: 'auth'\n    },\n    () =>\n      async function (ctx, next) {\n        const AUTH_ISSUER = env(ctx).AUTH_ISSUER\n\n        if (!AUTH_ISSUER) {\n          throw new Error('AUTH_ISSUER is not set')\n        }\n\n        if (!API_PRIVATE_KEY_FILE) {\n          // If the private key file is not loaded, try to load it from the environment\n          const AUTH_KEY = env(ctx).AUTH_KEY as string | undefined\n\n          API_PRIVATE_KEY_FILE = AUTH_KEY ? JSON.parse(AUTH_KEY) : undefined\n        }\n\n        if (!API_PRIVATE_KEY_FILE) {\n          throw new Error(\n            'You have initialized the auth middleware without a private key file'\n          )\n        }\n\n        const AUTH_PROJECT_ID = env(ctx).AUTH_PROJECT_ID\n\n        const ZITADEL_INTROSPECTION_URL = `${AUTH_ISSUER}/oauth/v2/introspect`\n\n        async function getRolesFromToken(tokenString: string) {\n          const response = await fetch(\n            `${AUTH_ISSUER}/auth/v1/usergrants/me/_search`,\n            {\n              method: 'POST',\n              headers: {\n                'Content-Type': 'application/json',\n                Authorization: `Bearer ${tokenString}`\n              }\n            }\n          )\n\n          const data = (await response.json()) as any\n\n          const userRoles = (data.result?.map((grant: any) => {\n            return (grant.roles || []).map((role: any) => {\n              return `${grant.projectId}:${role}`\n            })\n          }) || []) as string[][]\n\n          const projectScopedRoles = userRoles.flat()\n\n          const rolesSet = new Set(projectScopedRoles)\n\n          // Add unscoped roles based on project id\n          // This is useful so that it is not necessary to specify the project id for every role check\n          if (AUTH_PROJECT_ID) {\n            for (const role of projectScopedRoles) {\n              const [projectId, ...roleNameParts] = role.split(':')\n\n              const roleName = roleNameParts.join(':')\n\n              if (projectId === AUTH_PROJECT_ID) {\n                rolesSet.add(roleName)\n              }\n            }\n          }\n\n          return Array.from(rolesSet)\n        }\n\n        async function introspectToken(\n          tokenString: string\n        ): Promise<AuthState> {\n          if (!API_PRIVATE_KEY_FILE) {\n            throw new Error('Internal error: API_PRIVATE_KEY_FILE is not set')\n          }\n\n          // Create JWT for client assertion\n          const payload = {\n            iss: API_PRIVATE_KEY_FILE.clientId,\n            sub: API_PRIVATE_KEY_FILE.clientId,\n            aud: AUTH_ISSUER,\n            exp: Math.floor(Date.now() / 1000) + 60 * 60, // Expires in 1 hour\n            iat: Math.floor(Date.now() / 1000)\n          }\n\n          const headers = {\n            alg: 'RS256',\n            kid: API_PRIVATE_KEY_FILE.keyId\n          }\n          const jwtToken = jwt.sign(payload, API_PRIVATE_KEY_FILE.key, {\n            algorithm: 'RS256',\n            header: headers\n          })\n\n          const scopeSet = new Set<string>()\n\n          scopeSet.add('openid')\n          scopeSet.add('profile')\n          scopeSet.add('email')\n\n          if (AUTH_PROJECT_ID) {\n            scopeSet.add(\n              `urn:zitadel:iam:org:project:id:${AUTH_PROJECT_ID}:aud`\n            )\n          }\n\n          const scope = Array.from(scopeSet).join(' ')\n\n          // Send introspection request\n          const body = new URLSearchParams({\n            client_assertion_type:\n              'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',\n            client_assertion: jwtToken,\n            token: tokenString,\n            scope\n          }).toString()\n\n          try {\n            const response = await fetch(ZITADEL_INTROSPECTION_URL, {\n              method: 'POST',\n              headers: {'Content-Type': 'application/x-www-form-urlencoded'},\n              body\n            })\n\n            if (!response.ok) {\n              throw new Error('Network response was not ok')\n            }\n\n            const tokenData = (await response.json()) as IntrospectionResponse\n\n            const roles = await getRolesFromToken(tokenString)\n\n            const state = {\n              ...tokenData,\n              roles\n            } as AuthState\n\n            return state\n          } catch (error) {\n            console.error('Error while introspecting token', error)\n            throw new Error('Token introspection failed')\n          }\n        }\n\n        let token: string | undefined = undefined\n\n        if (ctx.req.header('Authorization')) {\n          const authHeader = ctx.req.header('Authorization')\n\n          if (authHeader) {\n            const parts = authHeader.split(' ')\n\n            if (parts.length === 2 && parts[0] === 'Bearer') {\n              token = parts[1]\n            }\n          }\n        }\n\n        if (!token) {\n          const queryToken = ctx.req.query('token')\n\n          if (queryToken) {\n            token = queryToken\n          }\n        }\n\n        if (token) {\n          const auth = await introspectToken(token)\n\n          if (auth.active) {\n            ctx.set('auth', auth)\n\n            Sentry.setUser({\n              id: auth.sub,\n              username: auth.preferred_username,\n              email: auth.email,\n              details: auth\n            })\n          }\n        }\n\n        return next()\n      }\n  )\n\n  sendFunctionEvent({\n    name: 'authInitialize',\n    duration: 0\n  }).then(() => {})\n\n  return middleware\n}\n\nexport type AuthRequireChecks = {\n  roles?: string[]\n}\n\nconst authRequire = (checks: AuthRequireChecks = {}) => {\n  sendFunctionEvent({\n    name: 'authRequire',\n    duration: 0\n  }).then(() => {})\n\n  const middleware: MiddlewareHandler<{\n    Variables: {\n      auth?: AuthState\n    }\n  }> = async (ctx, next) => {\n    const AUTH_PROJECT_ID = env(ctx).AUTH_PROJECT_ID\n\n    // Check if user is authenticated\n    const auth = ctx.get('auth')\n\n    if (!auth) {\n      throw new HTTPException(401, {\n        message: 'Authentication required'\n      })\n    }\n\n    if (checks.roles) {\n      const roles = auth.roles\n\n      const hasRole = checks.roles.some(role => {\n        return (\n          roles.includes(role) || roles.includes(`${AUTH_PROJECT_ID}:${role}`)\n        )\n      })\n\n      if (!hasRole) {\n        const resError = new Response('Forbidden', {\n          status: 403,\n          statusText: 'Forbidden',\n          headers: {\n            'Missing-Roles': checks.roles.join(','),\n            'Obtained-Roles': roles.join(',')\n          }\n        })\n\n        throw new HTTPException(resError.status as ContentfulStatusCode, {res: resError})\n      }\n    }\n\n    return next()\n  }\n\n  sendFunctionEvent({\n    name: 'authRequire',\n    duration: 0\n  }).then(() => {})\n\n  return middleware\n}\n\nexport const auth = {\n  initialize: authInitialize,\n  require: authRequire\n}\n\nexport {requireAuth} from './decorators/requireAuth'\n", "import {sendFunctionEvent} from '@getcronit/pylon-telemetry'\nimport {HTTPException} from 'hono/http-exception'\n\nimport {AuthRequireChecks, auth} from '..'\nimport {getContext} from '../../context'\nimport {ServiceError} from '../../define-pylon'\nimport {createDecorator} from '../../create-decorator'\n\nexport function requireAuth(checks?: AuthRequireChecks) {\n  sendFunctionEvent({\n    name: 'requireAuth',\n    duration: 0\n  }).then(() => {})\n\n  const checkAuth = async (c: any) => {\n    const ctx = await c\n\n    try {\n      await auth.require(checks)(ctx, async () => {})\n    } catch (e) {\n      if (e instanceof HTTPException) {\n        if (e.status === 401) {\n          throw new ServiceError(e.message, {\n            statusCode: 401,\n            code: 'AUTH_REQUIRED'\n          })\n        } else if (e.status === 403) {\n          const res = e.getResponse()\n\n          throw new ServiceError(res.statusText, {\n            statusCode: res.status,\n            code: 'AUTHORIZATION_REQUIRED',\n            details: {\n              missingRoles: res.headers.get('Missing-Roles')?.split(','),\n              obtainedRoles: res.headers.get('Obtained-Roles')?.split(',')\n            }\n          })\n        } else {\n          throw e\n        }\n      }\n\n      throw e\n    }\n  }\n\n  return createDecorator(async () => {\n    const ctx = getContext()\n\n    await checkAuth(ctx)\n  })\n}\n", "import {sendFunctionEvent} from '@getcronit/pylon-telemetry'\n\nexport function createDecorator(callback: (...args: any[]) => Promise<void>) {\n  sendFunctionEvent({\n    name: 'createDecorator',\n    duration: 0\n  }).then(() => {})\n\n  function MyDecorator<T extends (...args: any[]) => any>(\n    target: Object,\n    propertyKey: string | symbol\n  ): void\n\n  function MyDecorator<T>(fn: T): T\n\n  function MyDecorator<T>(\n    arg1: Object | T,\n    propertyKey?: string | symbol,\n    descriptor?: PropertyDescriptor\n  ): any {\n    if (descriptor) {\n      const originalMethod = descriptor.value as T\n\n      descriptor.value = async function (...args: any[]) {\n        await callback(...args)\n        return (originalMethod as any).apply(this, args)\n      }\n\n      return descriptor\n    } else {\n      if (!descriptor) {\n        if (propertyKey === undefined) {\n          const originalFunction = arg1 as T\n\n          return async function (\n            ...args: Parameters<any>\n          ): Promise<ReturnType<any>> {\n            await callback(...args)\n            return (originalFunction as any)(...args)\n          } as T\n        }\n\n        let value: any = arg1[propertyKey]\n        Object.defineProperty(arg1, propertyKey, {\n          get: function () {\n            return async function (...args: Parameters<any>) {\n              await callback(...args)\n              if (typeof value === 'function') {\n                return value(...args)\n              }\n\n              return value\n            }\n          },\n          set: function (newValue) {\n            value = newValue\n          },\n          enumerable: true,\n          configurable: true\n        })\n\n        return\n      }\n    }\n  }\n\n  return MyDecorator\n}\n", "import {Hono} from 'hono'\nimport {logger} from 'hono/logger'\nimport {sentry} from '@hono/sentry'\n\nimport {asyncContext, Env} from '../context'\nimport {graphqlViewerHandler} from './handler/graphql-viewer-handler'\n\nexport const app = new Hono<Env>()\n\napp.use('*', sentry())\n\napp.use('*', async (c, next) => {\n  return new Promise((resolve, reject) => {\n    asyncContext.run(c, async () => {\n      try {\n        resolve(await next()) // You can pass the value you want to return here\n      } catch (error) {\n        reject(error) // If an error occurs during the execution of `next()`, reject the Promise\n      }\n    })\n  })\n})\n\napp.use('*', logger())\n\napp.use((c, next) => {\n  // @ts-ignore\n  c.req.id = crypto.randomUUID()\n  return next()\n})\n\napp.get('/viewer', graphqlViewerHandler)\n", "import type {MiddlewareHandler} from 'hono'\nimport {html} from 'hono/html'\n\nexport const graphqlViewerHandler: MiddlewareHandler = async (c, next) => {\n  return c.html(html`\n    <!DOCTYPE html>\n    <html>\n      <head>\n        <title>Pylon Viewer</title>\n        <script src=\"https://cdn.jsdelivr.net/npm/react@16/umd/react.production.min.js\"></script>\n        <script src=\"https://cdn.jsdelivr.net/npm/react-dom@16/umd/react-dom.production.min.js\"></script>\n\n        <link\n          rel=\"stylesheet\"\n          href=\"https://cdn.jsdelivr.net/npm/graphql-voyager/dist/voyager.css\"\n        />\n        <style>\n            body {\n              padding: 0;\n              margin: 0;\n              width: 100%;\n              height: 100vh;\n              overflow: hidden;\n            }\n\n            #voyager {\n              height: 100%;\n              position: relative;\n            }\n          }\n        </style>\n        <script src=\"https://cdn.jsdelivr.net/npm/graphql-voyager/dist/voyager.min.js\"></script>\n      </head>\n      <body>\n        <div id=\"voyager\">Loading...</div>\n        <script>\n          function introspectionProvider(introspectionQuery) {\n            // ... do a call to server using introspectionQuery provided\n            // or just return pre-fetched introspection\n\n            // Endpoint is current path instead of root/graphql\n            const endpoint = window.location.pathname.replace(\n              '/viewer',\n              '/graphql'\n            )\n\n            return fetch(endpoint, {\n              method: 'post',\n              headers: {\n                'Content-Type': 'application/json'\n              },\n              body: JSON.stringify({query: introspectionQuery})\n            }).then(response => response.json())\n          }\n\n          // Render <Voyager />\n          GraphQLVoyager.init(document.getElementById('voyager'), {\n            introspection: introspectionProvider\n          })\n        </script>\n      </body>\n    </html>\n  `)\n}\n", "import {createSchema, createYoga} from 'graphql-yoga'\nimport {GraphQLScalarType, Kind} from 'graphql'\nimport {\n  DateTimeISOResolver,\n  GraphQLVoid,\n  JSONObjectResolver,\n  JSONResolver\n} from 'graphql-scalars'\n\nimport {useSentry} from '../envelop/use-sentry'\nimport {Context} from '../../context'\nimport {resolversToGraphQLResolvers} from '../../define-pylon'\nimport {PylonConfig} from '../..'\nimport {readFileSync} from 'fs'\nimport path from 'path'\n\ninterface PylonHandlerOptions {\n  graphql: {\n    Query: Record<string, any>\n    Mutation?: Record<string, any>\n    Subscription?: Record<string, any>\n  }\n  config?: PylonConfig\n}\n\nexport const handler = (options: PylonHandlerOptions) => {\n  let {typeDefs, resolvers, graphql, config} =\n    options as PylonHandlerOptions & {\n      typeDefs?: string\n      resolvers?: Record<string, any>\n    }\n\n  if (!typeDefs) {\n    // Try to read the schema from the default location\n    const schemaPath = path.join(process.cwd(), '.pylon', 'schema.graphql')\n\n    // If `schemaPath` is provided, read the schema from the file\n    if (schemaPath) {\n      typeDefs = readFileSync(schemaPath, 'utf-8')\n    }\n  }\n\n  if (!typeDefs) {\n    throw new Error('No schema provided.')\n  }\n\n  if (!resolvers) {\n    // Try to read the resolvers from the default location\n    const resolversPath = path.join(process.cwd(), '.pylon', 'resolvers.js')\n\n    // If `resolversPath` is provided, read the resolvers from the file\n\n    if (resolversPath) {\n      resolvers = require(resolversPath).resolvers\n    }\n  }\n\n  const graphqlResolvers = resolversToGraphQLResolvers(graphql)\n\n  const schema = createSchema<Context>({\n    typeDefs,\n    resolvers: {\n      ...graphqlResolvers,\n      ...resolvers,\n      // Transforms a date object to a timestamp\n      Date: DateTimeISOResolver,\n      JSON: JSONResolver,\n      Object: JSONObjectResolver,\n      Void: GraphQLVoid,\n      Number: new GraphQLScalarType({\n        name: 'Number',\n        description: 'Custom scalar that handles both integers and floats',\n\n        // Parsing input from query variables\n        parseValue(value) {\n          if (typeof value !== 'number') {\n            throw new TypeError(`Value is not a number: ${value}`)\n          }\n          return value // Valid number\n        },\n\n        // Validation when sending from client (input literals)\n        parseLiteral(ast) {\n          if (ast.kind === Kind.INT || ast.kind === Kind.FLOAT) {\n            return parseFloat(ast.value) // Convert the value to a float\n          }\n          throw new TypeError(\n            `Value is not a valid number or float: ${\n              'value' in ast ? ast.value : ast\n            }`\n          )\n        },\n\n        // Serialize output to be sent to the client\n        serialize(value) {\n          if (typeof value !== 'number') {\n            throw new TypeError(`Value is not a number: ${value}`)\n          }\n          return value\n        }\n      })\n    }\n  })\n\n  const yoga = createYoga({\n    landingPage: false,\n    graphiql: req => {\n      return {\n        shouldPersistHeaders: true,\n        title: 'Pylon Playground',\n        defaultQuery: `# Welcome to the Pylon Playground!`\n      }\n    },\n    graphqlEndpoint: '/graphql',\n    ...config,\n    plugins: [useSentry(), ...(config?.plugins || [])],\n    schema\n  })\n\n  const handler = async (c: Context): Promise<Response> => {\n    let executionContext: Context['executionCtx'] | {} = {}\n\n    try {\n      executionContext = c.executionCtx\n    } catch (e) {}\n\n    const response = await yoga.fetch(c.req.raw, c.env, executionContext)\n\n    return c.newResponse(response.body, response)\n  }\n\n  return handler\n}\n", "import {GraphQLError, Kind, OperationDefinitionNode, print} from 'graphql'\nimport {\n  getDocumentString,\n  handleStreamOrSingleExecutionResult,\n  isOriginalGraphQLError,\n  OnExecuteDoneHookResultOnNextHook,\n  TypedExecutionArgs,\n  type Plugin\n} from '@envelop/core'\nimport * as Sentry from '@sentry/node'\nimport type {Span, TraceparentData} from '@sentry/types'\n\nexport type SentryPluginOptions<PluginContext extends Record<string, any>> = {\n  /**\n   * Starts a new transaction for every GraphQL Operation.\n   * When disabled, an already existing Transaction will be used.\n   *\n   * @default true\n   */\n  startTransaction?: boolean\n  /**\n   * Renames Transaction.\n   * @default false\n   */\n  renameTransaction?: boolean\n  /**\n   * Adds result of each resolver and operation to Span's data (available under \"result\")\n   * @default false\n   */\n  includeRawResult?: boolean\n  /**\n   * Adds operation's variables to a Scope (only in case of errors)\n   * @default false\n   */\n  includeExecuteVariables?: boolean\n  /**\n   * The key of the event id in the error's extension. `null` to disable.\n   * @default sentryEventId\n   */\n  eventIdKey?: string | null\n  /**\n   * Adds custom tags to every Transaction.\n   */\n  appendTags?: (\n    args: TypedExecutionArgs<PluginContext>\n  ) => Record<string, unknown>\n  /**\n   * Callback to set context information onto the scope.\n   */\n  configureScope?: (\n    args: TypedExecutionArgs<PluginContext>,\n    scope: Sentry.Scope\n  ) => void\n  /**\n   * Produces a name of Transaction (only when \"renameTransaction\" or \"startTransaction\" are enabled) and description of created Span.\n   *\n   * @default operation's name or \"Anonymous Operation\" when missing)\n   */\n  transactionName?: (args: TypedExecutionArgs<PluginContext>) => string\n  /**\n   * Produces tracing data for Transaction\n   *\n   * @default is empty\n   */\n  traceparentData?: (\n    args: TypedExecutionArgs<PluginContext>\n  ) => TraceparentData | undefined\n  /**\n   * Produces a \"op\" (operation) of created Span.\n   *\n   * @default execute\n   */\n  operationName?: (args: TypedExecutionArgs<PluginContext>) => string\n  /**\n   * Indicates whether or not to skip the entire Sentry flow for given GraphQL operation.\n   * By default, no operations are skipped.\n   */\n  skip?: (args: TypedExecutionArgs<PluginContext>) => boolean\n  /**\n   * Indicates whether or not to skip Sentry exception reporting for a given error.\n   * By default, this plugin skips all `GraphQLError` errors and does not report it to Sentry.\n   */\n  skipError?: (args: Error) => boolean\n}\n\nexport const defaultSkipError = isOriginalGraphQLError\n\nexport const useSentry = <PluginContext extends Record<string, any> = {}>(\n  options: SentryPluginOptions<PluginContext> = {}\n): Plugin<PluginContext> => {\n  function pick<K extends keyof SentryPluginOptions<PluginContext>>(\n    key: K,\n    defaultValue: NonNullable<SentryPluginOptions<PluginContext>[K]>\n  ) {\n    return options[key] ?? defaultValue\n  }\n\n  const startTransaction = pick('startTransaction', true)\n  const includeRawResult = pick('includeRawResult', false)\n  const includeExecuteVariables = pick('includeExecuteVariables', false)\n  const renameTransaction = pick('renameTransaction', false)\n  const skipOperation = pick('skip', () => false)\n  const skipError = pick('skipError', defaultSkipError)\n\n  const eventIdKey = options.eventIdKey === null ? null : 'sentryEventId'\n\n  function addEventId(err: GraphQLError, eventId: string | null): GraphQLError {\n    if (eventIdKey !== null && eventId !== null) {\n      err.extensions[eventIdKey] = eventId\n    }\n\n    return err\n  }\n\n  return {\n    onExecute({args}) {\n      if (skipOperation(args)) {\n        return\n      }\n\n      const rootOperation = args.document.definitions.find(\n        o => o.kind === Kind.OPERATION_DEFINITION\n      ) as OperationDefinitionNode\n      const operationType = rootOperation.operation\n\n      const document = getDocumentString(args.document, print)\n\n      const opName =\n        args.operationName || rootOperation.name?.value || 'Anonymous Operation'\n      const addedTags: Record<string, any> =\n        (options.appendTags && options.appendTags(args)) || {}\n      const traceparentData =\n        (options.traceparentData && options.traceparentData(args)) || {}\n\n      const transactionName = options.transactionName\n        ? options.transactionName(args)\n        : opName\n      const op = options.operationName ? options.operationName(args) : 'execute'\n      const tags = {\n        operationName: opName,\n        operation: operationType,\n        ...addedTags\n      }\n\n      if (options.configureScope) {\n        options.configureScope(args, Sentry.getCurrentScope())\n      }\n\n      return {\n        onExecuteDone(payload) {\n          const handleResult: OnExecuteDoneHookResultOnNextHook<{}> = ({\n            result,\n            setResult\n          }) => {\n            Sentry.startSpanManual(\n              {\n                op,\n                name: opName,\n                attributes: tags\n              },\n              span => {\n                if (renameTransaction) {\n                  span.updateName(transactionName)\n                }\n\n                span.setAttribute('document', document)\n\n                if (includeRawResult) {\n                  span.setAttribute('result', JSON.stringify(result))\n                }\n\n                if (result.errors && result.errors.length > 0) {\n                  Sentry.withScope(scope => {\n                    scope.setTransactionName(opName)\n                    scope.setTag('operation', operationType)\n                    scope.setTag('operationName', opName)\n                    scope.setExtra('document', document)\n\n                    scope.setTags(addedTags || {})\n\n                    if (includeRawResult) {\n                      scope.setExtra('result', result)\n                    }\n\n                    if (includeExecuteVariables) {\n                      scope.setExtra('variables', args.variableValues)\n                    }\n\n                    const errors = result.errors?.map(err => {\n                      if (skipError(err) === true) {\n                        return err\n                      }\n\n                      const errorPath = (err.path ?? [])\n                        .map((v: string | number) =>\n                          typeof v === 'number' ? '$index' : v\n                        )\n                        .join(' > ')\n\n                      if (errorPath) {\n                        scope.addBreadcrumb({\n                          category: 'execution-path',\n                          message: errorPath,\n                          level: 'debug'\n                        })\n                      }\n\n                      const eventId = Sentry.captureException(\n                        err.originalError,\n                        {\n                          fingerprint: [\n                            'graphql',\n                            errorPath,\n                            opName,\n                            operationType\n                          ],\n                          contexts: {\n                            GraphQL: {\n                              operationName: opName,\n                              operationType,\n                              variables: args.variableValues\n                            }\n                          }\n                        }\n                      )\n\n                      return addEventId(err, eventId)\n                    })\n\n                    setResult({\n                      ...result,\n                      errors\n                    })\n                  })\n                }\n\n                span.end()\n              }\n            )\n          }\n          return handleStreamOrSingleExecutionResult(payload, handleResult)\n        }\n      }\n    }\n  }\n}\n", "import {sendFunctionEvent} from '@getcronit/pylon-telemetry'\nimport {asyncContext, Context} from './context'\n\nexport function getEnv() {\n  const start = Date.now()\n  const skipTracing = arguments[0] === true\n\n  try {\n    const context = asyncContext.getStore() as Context\n\n    // Fall back to process.env or an empty object if no context is available\n    // This is useful for testing\n    // ref: https://hono.dev/docs/guides/testing#env\n    return context.env || process.env || {}\n  } catch {\n    return process.env\n  } finally {\n    if (!skipTracing) {\n      sendFunctionEvent({\n        name: 'getEnv',\n        duration: Date.now() - start\n      }).then(() => {})\n    }\n  }\n}\n", "import {YogaServerOptions} from 'graphql-yoga'\nimport {Context} from './context.js'\n\nexport {ServiceError} from './define-pylon.js'\nexport * from './auth/index.js'\nexport {\n  Context,\n  Env,\n  Variables,\n  Bindings,\n  asyncContext,\n  getContext,\n  setContext\n} from './context.js'\nexport {app} from './app/index.js'\nexport {handler} from './app/handler/pylon-handler.js'\nexport {getEnv} from './get-env.js'\nexport {createDecorator} from './create-decorator.js'\nexport {createPubSub as experimentalCreatePubSub} from 'graphql-yoga'\n\nexport type PylonConfig = Pick<YogaServerOptions<Context, Context>, 'plugins'>\n\nexport type ID = string & {readonly brand?: unique symbol}\nexport type Int = number & {readonly brand?: unique symbol}\nexport type Float = number & {readonly brand?: unique symbol}\n"],
  "mappings": "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",
  "names": ["Sentry", "consola", "GraphQLError", "AsyncLocalStorage", "sendFunctionEvent", "env", "asyncContext", "getContext", "start", "ctx", "setContext", "context", "isAsyncIterable", "getAllPropertyNames", "instance", "allProps", "currentObj", "prop", "wrapFunctionsRecursively", "obj", "wrapper", "that", "selectionSet", "info", "item", "result", "key", "spreadFunctionArguments", "fn", "otherArgs", "c", "selections", "realInfo", "args", "preparedArguments", "acc", "arg", "orderedArgs", "resolversToGraphQLResolvers", "resolvers", "configureContext", "rootGraphqlResolver", "_", "ctx", "scope", "asyncContext", "consola", "auth", "type", "inner", "baseSelectionSet", "selection", "wrappedFn", "graphqlResolvers", "value", "payload", "ServiceError", "GraphQLError", "message", "extensions", "error", "jwt", "path", "HTTPException", "env", "Sentry", "existsSync", "readFileSync", "sendFunctionEvent", "sendFunctionEvent", "HTTPException", "sendFunctionEvent", "createDecorator", "callback", "MyDecorator", "arg1", "propertyKey", "descriptor", "originalMethod", "args", "originalFunction", "value", "newValue", "requireAuth", "checks", "sendFunctionEvent", "checkAuth", "c", "ctx", "auth", "e", "HTTPException", "ServiceError", "res", "createDecorator", "getContext", "authInitialize", "authKeyFilePath", "path", "API_PRIVATE_KEY_FILE", "existsSync", "readFileSync", "middleware", "ctx", "next", "AUTH_ISSUER", "env", "AUTH_KEY", "AUTH_PROJECT_ID", "ZITADEL_INTROSPECTION_URL", "getRolesFromToken", "tokenString", "projectScopedRoles", "grant", "role", "rolesSet", "projectId", "roleNameParts", "roleName", "introspectToken", "payload", "headers", "jwtToken", "jwt", "scopeSet", "scope", "body", "response", "tokenData", "roles", "error", "token", "authHeader", "parts", "queryToken", "auth", "sendFunctionEvent", "authRequire", "checks", "HTTPException", "resError", "Hono", "logger", "sentry", "html", "graphqlViewerHandler", "c", "next", "app", "Hono", "sentry", "c", "next", "resolve", "reject", "asyncContext", "error", "logger", "graphqlViewerHandler", "createSchema", "createYoga", "GraphQLScalarType", "Kind", "DateTimeISOResolver", "GraphQLVoid", "JSONObjectResolver", "JSONResolver", "Kind", "print", "getDocumentString", "handleStreamOrSingleExecutionResult", "isOriginalGraphQLError", "Sentry", "defaultSkipError", "useSentry", "options", "pick", "key", "defaultValue", "startTransaction", "includeRawResult", "includeExecuteVariables", "renameTransaction", "skipOperation", "skipError", "eventIdKey", "addEventId", "err", "eventId", "args", "rootOperation", "o", "operationType", "document", "opName", "addedTags", "traceparentData", "transactionName", "op", "tags", "payload", "result", "setResult", "span", "scope", "errors", "errorPath", "v", "readFileSync", "path", "handler", "options", "typeDefs", "resolvers", "graphql", "config", "schemaPath", "path", "readFileSync", "resolversPath", "__require", "graphqlResolvers", "resolversToGraphQLResolvers", "schema", "createSchema", "DateTimeISOResolver", "JSONResolver", "JSONObjectResolver", "GraphQLVoid", "GraphQLScalarType", "value", "ast", "Kind", "yoga", "createYoga", "req", "useSentry", "executionContext", "response", "sendFunctionEvent", "getEnv", "start", "skipTracing", "asyncContext", "sendFunctionEvent", "createPubSub"]
}

+  `);
+};
+
+// src/app/index.ts
+var app = new Hono();
+app.use("*", sentry());
+app.use("*", async (c, next) => {
+  return new Promise((resolve, reject) => {
+    asyncContext.run(c, async () => {
+      try {
+        resolve(await next());
+      } catch (error) {
+        reject(error);
+      }
+    });
+  });
+});
+app.use("*", logger());
+app.use((c, next) => {
+  c.req.id = crypto.randomUUID();
+  return next();
+});
+app.get("/viewer", graphqlViewerHandler);
+
+// src/app/handler/pylon-handler.ts
+import { createSchema, createYoga } from "graphql-yoga";
+import { GraphQLScalarType, Kind as Kind2 } from "graphql";
+import {
+  DateTimeISOResolver,
+  GraphQLVoid,
+  JSONObjectResolver,
+  JSONResolver
+} from "graphql-scalars";
+
+// src/app/envelop/use-sentry.ts
+import { Kind, print } from "graphql";
+import {
+  getDocumentString,
+  handleStreamOrSingleExecutionResult,
+  isOriginalGraphQLError
+} from "@envelop/core";
+import * as Sentry3 from "@sentry/node";
+var defaultSkipError = isOriginalGraphQLError;
+var useSentry = (options = {}) => {
+  function pick(key, defaultValue) {
+    return options[key] ?? defaultValue;
+  }
+  const startTransaction = pick("startTransaction", true);
+  const includeRawResult = pick("includeRawResult", false);
+  const includeExecuteVariables = pick("includeExecuteVariables", false);
+  const renameTransaction = pick("renameTransaction", false);
+  const skipOperation = pick("skip", () => false);
+  const skipError = pick("skipError", defaultSkipError);
+  const eventIdKey = options.eventIdKey === null ? null : "sentryEventId";
+  function addEventId(err, eventId) {
+    if (eventIdKey !== null && eventId !== null) {
+      err.extensions[eventIdKey] = eventId;
+    }
+    return err;
+  }
+  return {
+    onExecute({ args }) {
+      if (skipOperation(args)) {
+        return;
+      }
+      const rootOperation = args.document.definitions.find(
+        (o) => o.kind === Kind.OPERATION_DEFINITION
+      );
+      const operationType = rootOperation.operation;
+      const document = getDocumentString(args.document, print);
+      const opName = args.operationName || rootOperation.name?.value || "Anonymous Operation";
+      const addedTags = options.appendTags && options.appendTags(args) || {};
+      const traceparentData = options.traceparentData && options.traceparentData(args) || {};
+      const transactionName = options.transactionName ? options.transactionName(args) : opName;
+      const op = options.operationName ? options.operationName(args) : "execute";
+      const tags = {
+        operationName: opName,
+        operation: operationType,
+        ...addedTags
+      };
+      if (options.configureScope) {
+        options.configureScope(args, Sentry3.getCurrentScope());
+      }
+      return {
+        onExecuteDone(payload) {
+          const handleResult = ({
+            result,
+            setResult
+          }) => {
+            Sentry3.startSpanManual(
+              {
+                op,
+                name: opName,
+                attributes: tags
+              },
+              (span) => {
+                if (renameTransaction) {
+                  span.updateName(transactionName);
+                }
+                span.setAttribute("document", document);
+                if (includeRawResult) {
+                  span.setAttribute("result", JSON.stringify(result));
+                }
+                if (result.errors && result.errors.length > 0) {
+                  Sentry3.withScope((scope) => {
+                    scope.setTransactionName(opName);
+                    scope.setTag("operation", operationType);
+                    scope.setTag("operationName", opName);
+                    scope.setExtra("document", document);
+                    scope.setTags(addedTags || {});
+                    if (includeRawResult) {
+                      scope.setExtra("result", result);
+                    }
+                    if (includeExecuteVariables) {
+                      scope.setExtra("variables", args.variableValues);
+                    }
+                    const errors = result.errors?.map((err) => {
+                      if (skipError(err) === true) {
+                        return err;
+                      }
+                      const errorPath = (err.path ?? []).map(
+                        (v) => typeof v === "number" ? "$index" : v
+                      ).join(" > ");
+                      if (errorPath) {
+                        scope.addBreadcrumb({
+                          category: "execution-path",
+                          message: errorPath,
+                          level: "debug"
+                        });
+                      }
+                      const eventId = Sentry3.captureException(
+                        err.originalError,
+                        {
+                          fingerprint: [
+                            "graphql",
+                            errorPath,
+                            opName,
+                            operationType
+                          ],
+                          contexts: {
+                            GraphQL: {
+                              operationName: opName,
+                              operationType,
+                              variables: args.variableValues
+                            }
+                          }
+                        }
+                      );
+                      return addEventId(err, eventId);
+                    });
+                    setResult({
+                      ...result,
+                      errors
+                    });
+                  });
+                }
+                span.end();
+              }
+            );
+          };
+          return handleStreamOrSingleExecutionResult(payload, handleResult);
+        }
+      };
+    }
+  };
+};
+
+// src/app/handler/pylon-handler.ts
+import { readFileSync as readFileSync2 } from "fs";
+import path2 from "path";
+var handler = (options) => {
+  let { typeDefs, resolvers, graphql, config } = options;
+  if (!typeDefs) {
+    const schemaPath = path2.join(process.cwd(), ".pylon", "schema.graphql");
+    if (schemaPath) {
+      typeDefs = readFileSync2(schemaPath, "utf-8");
+    }
+  }
+  if (!typeDefs) {
+    throw new Error("No schema provided.");
+  }
+  if (!resolvers) {
+    const resolversPath = path2.join(process.cwd(), ".pylon", "resolvers.js");
+    if (resolversPath) {
+      resolvers = __require(resolversPath).resolvers;
+    }
+  }
+  const graphqlResolvers = resolversToGraphQLResolvers(graphql);
+  const schema = createSchema({
+    typeDefs,
+    resolvers: {
+      ...graphqlResolvers,
+      ...resolvers,
+      // Transforms a date object to a timestamp
+      Date: DateTimeISOResolver,
+      JSON: JSONResolver,
+      Object: JSONObjectResolver,
+      Void: GraphQLVoid,
+      Number: new GraphQLScalarType({
+        name: "Number",
+        description: "Custom scalar that handles both integers and floats",
+        // Parsing input from query variables
+        parseValue(value) {
+          if (typeof value !== "number") {
+            throw new TypeError(`Value is not a number: ${value}`);
+          }
+          return value;
+        },
+        // Validation when sending from client (input literals)
+        parseLiteral(ast) {
+          if (ast.kind === Kind2.INT || ast.kind === Kind2.FLOAT) {
+            return parseFloat(ast.value);
+          }
+          throw new TypeError(
+            `Value is not a valid number or float: ${"value" in ast ? ast.value : ast}`
+          );
+        },
+        // Serialize output to be sent to the client
+        serialize(value) {
+          if (typeof value !== "number") {
+            throw new TypeError(`Value is not a number: ${value}`);
+          }
+          return value;
+        }
+      })
+    }
+  });
+  const yoga = createYoga({
+    landingPage: false,
+    graphiql: (req) => {
+      return {
+        shouldPersistHeaders: true,
+        title: "Pylon Playground",
+        defaultQuery: `# Welcome to the Pylon Playground!`
+      };
+    },
+    graphqlEndpoint: "/graphql",
+    ...config,
+    plugins: [useSentry(), ...config?.plugins || []],
+    schema
+  });
+  const handler2 = async (c) => {
+    let executionContext = {};
+    try {
+      executionContext = c.executionCtx;
+    } catch (e) {
+    }
+    const response = await yoga.fetch(c.req.raw, c.env, executionContext);
+    return c.newResponse(response.body, response);
+  };
+  return handler2;
+};
+
+// src/get-env.ts
+import { sendFunctionEvent as sendFunctionEvent5 } from "@getcronit/pylon-telemetry";
+function getEnv() {
+  const start = Date.now();
+  const skipTracing = arguments[0] === true;
+  try {
+    const context = asyncContext.getStore();
+    return context.env || process.env || {};
+  } catch {
+    return process.env;
+  } finally {
+    if (!skipTracing) {
+      sendFunctionEvent5({
+        name: "getEnv",
+        duration: Date.now() - start
+      }).then(() => {
+      });
+    }
+  }
+}
+
+// src/index.ts
+import { createPubSub } from "graphql-yoga";
+export {
+  ServiceError,
+  app,
+  asyncContext,
+  auth,
+  createDecorator,
+  createPubSub as experimentalCreatePubSub,
+  getContext,
+  getEnv,
+  handler,
+  requireAuth,
+  setContext
+};
+//# sourceMappingURL=index.js.map