@orion-js/graphql 4.0.0-next.2 → 4.0.0-next.3

package/dist/index.js

@@ -1,14 +1,11 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-
 // src/pubsub.ts
 var pubsub = null;
-var setPubsub = /* @__PURE__ */ __name(function(newPubsub) {
+var setPubsub = function(newPubsub) {
   pubsub = newPubsub;
-}, "setPubsub");
-var getPubsub = /* @__PURE__ */ __name(function() {
+};
+var getPubsub = function() {
   return pubsub;
-}, "getPubsub");
+};
 
 // src/subscription/getChannelName.ts
 import { hashObject } from "@orion-js/helpers";
@@ -17,29 +14,26 @@ function getChannelName_default(name, params) {
   const channelName = `${name}_${hash}`;
   return channelName;
 }
-__name(getChannelName_default, "default");
 
 // src/subscription/index.ts
-import { checkPermissions as checkResolverPermissions, cleanParams, cleanReturns } from "@orion-js/resolvers";
-var createSubscription = /* @__PURE__ */ __name(function(options) {
+import {
+  checkPermissions as checkResolverPermissions,
+  cleanParams,
+  cleanReturns
+} from "@orion-js/resolvers";
+var createSubscription = function(options) {
   const subscription = {
     name: options.name
   };
   subscription.publish = async (params, data) => {
     const pubsub2 = getPubsub();
     const channelName = getChannelName_default(subscription.name, params);
-    await pubsub2.publish(channelName, {
-      [subscription.name]: data
-    });
+    await pubsub2.publish(channelName, { [subscription.name]: data });
   };
   subscription.subscribe = async (params, viewer) => {
     const pubsub2 = getPubsub();
     try {
-      await checkResolverPermissions({
-        params,
-        viewer,
-        options: null
-      }, options);
+      await checkResolverPermissions({ params, viewer, options: null }, options);
       const channelName = getChannelName_default(subscription.name, params);
       return pubsub2.asyncIterator(channelName);
     } catch (error) {
@@ -49,7 +43,7 @@ var createSubscription = /* @__PURE__ */ __name(function(options) {
   subscription.params = cleanParams(options.params);
   subscription.returns = cleanReturns(options.returns);
   return subscription;
-}, "createSubscription");
+};
 var subscription_default = createSubscription;
 
 // src/startGraphiQL.ts
@@ -57,8 +51,7 @@ import { registerRoute, route } from "@orion-js/http";
 function safeSerialize(data) {
   return data ? JSON.stringify(data).replace(/\//g, "\\/") : null;
 }
-__name(safeSerialize, "safeSerialize");
-var getHTML = /* @__PURE__ */ __name(function(apolloOptions, options, data) {
+var getHTML = function(apolloOptions, options, data) {
   const GRAPHIQL_VERSION = "0.11.11";
   const endpointURL = "/graphql";
   const subscriptionsEndpoint = "/subscriptions";
@@ -239,19 +232,20 @@ var getHTML = /* @__PURE__ */ __name(function(apolloOptions, options, data) {
   </script>
 </body>
 </html>`;
-}, "getHTML");
+};
 function startGraphiQL_default(apolloOptions, options) {
-  registerRoute(route({
-    path: "/graphiql",
-    method: "get",
-    async resolve(req) {
-      return {
-        body: getHTML(apolloOptions, options, req.query)
-      };
-    }
-  }));
+  registerRoute(
+    route({
+      path: "/graphiql",
+      method: "get",
+      async resolve(req) {
+        return {
+          body: getHTML(apolloOptions, options, req.query)
+        };
+      }
+    })
+  );
 }
-__name(startGraphiQL_default, "default");
 
 // src/buildSchema/index.ts
 import { GraphQLSchema } from "graphql";
@@ -269,7 +263,7 @@ import { getFieldType as getFieldType2 } from "@orion-js/schema";
 import { GraphQLScalarType } from "graphql";
 var MAX_INT = Number.MAX_SAFE_INTEGER;
 var MIN_INT = Number.MIN_SAFE_INTEGER;
-var coerceBigInt = /* @__PURE__ */ __name(function coerceBigInt2(value) {
+var coerceBigInt = function coerceBigInt2(value) {
   if (value === "") {
     throw new TypeError("BigInt cannot represent non 53-bit signed integer value: (empty string)");
   }
@@ -282,7 +276,7 @@ var coerceBigInt = /* @__PURE__ */ __name(function coerceBigInt2(value) {
     throw new TypeError("BigInt cannot represent non-integer value: " + String(value));
   }
   return int;
-}, "coerceBigInt");
+};
 var BigIntScalar_default = new GraphQLScalarType({
   name: "BigInt",
   description: "The `BigInt` scalar type represents non-fractional signed whole numeric values. BigInt can represent values between -(2^53) + 1 and 2^53 - 1. ",
@@ -314,7 +308,6 @@ import { GraphQLScalarType as GraphQLScalarType3, Kind } from "graphql";
 function identity(value) {
   return value;
 }
-__name(identity, "identity");
 function parseLiteral(ast, variables) {
   switch (ast.kind) {
     case Kind.STRING:
@@ -342,7 +335,6 @@ function parseLiteral(ast, variables) {
       return void 0;
   }
 }
-__name(parseLiteral, "parseLiteral");
 var JSONScalar_default = new GraphQLScalarType3({
   name: "JSON",
   description: "The `JSON` scalar type represents JSON values as specified by [ECMA-404](http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-404.pdf).",
@@ -378,7 +370,6 @@ function getScalar_default(fieldType) {
   }
   throw new Error(`Field type "${fieldType.name}" has no convertion to GraphQLType`);
 }
-__name(getScalar_default, "default");
 
 // src/buildSchema/getArgs/getField.ts
 import isPlainObject from "lodash/isPlainObject";
@@ -399,11 +390,10 @@ function getStaticFields(model) {
     };
   }).filter((field) => !field.private);
 }
-__name(getStaticFields, "getStaticFields");
 
 // src/buildSchema/getArgs/getField.ts
 var storedModelInput = {};
-var getModelInput = /* @__PURE__ */ __name(function(model, fields) {
+var getModelInput = function(model, fields) {
   if (storedModelInput[model.name]) {
     return storedModelInput[model.name];
   }
@@ -412,7 +402,7 @@ var getModelInput = /* @__PURE__ */ __name(function(model, fields) {
     fields
   });
   return storedModelInput[model.name];
-}, "getModelInput");
+};
 function getParams(type) {
   if (!type) {
     throw new Error(`No type specified`);
@@ -436,7 +426,6 @@ function getParams(type) {
     return graphQLType;
   }
 }
-__name(getParams, "getParams");
 
 // src/buildSchema/getArgs/index.ts
 function getArgs_default(params) {
@@ -446,16 +435,13 @@ function getArgs_default(params) {
   for (const key of Object.keys(params)) {
     try {
       const type = getParams(params[key].type);
-      fields[key] = {
-        type
-      };
+      fields[key] = { type };
     } catch (error) {
       throw new Error(`Error creating GraphQL resolver params argument ${key}: ${error.message}`);
     }
   }
   return fields;
 }
-__name(getArgs_default, "default");
 
 // src/errorHandler.ts
 import crypto from "crypto";
@@ -489,7 +475,6 @@ function errorHandler(error, data) {
     });
   }
 }
-__name(errorHandler, "errorHandler");
 
 // src/buildSchema/getType/getTypeAsResolver.ts
 function getTypeAsResolver_default({ resolver: resolver4, getGraphQLType: getGraphQLType2, options, model }) {
@@ -503,18 +488,12 @@ function getTypeAsResolver_default({ resolver: resolver4, getGraphQLType: getGra
         const result = await resolver4.resolve(item, params, context, info);
         return result;
       } catch (error) {
-        errorHandler(error, {
-          context,
-          resolver: resolver4,
-          options,
-          model
-        });
+        errorHandler(error, { context, resolver: resolver4, options, model });
         throw error;
       }
     }
   };
 }
-__name(getTypeAsResolver_default, "default");
 
 // src/resolversSchemas/getDynamicFields.ts
 function getDynamicFields(model) {
@@ -529,7 +508,6 @@ function getDynamicFields(model) {
     };
   }).filter((resolver4) => !resolver4.private);
 }
-__name(getDynamicFields, "getDynamicFields");
 
 // src/resolversSchemas/getModelLoadedResolvers.ts
 function getModelLoadedResolvers(model, options) {
@@ -545,7 +523,6 @@ function getModelLoadedResolvers(model, options) {
     };
   }).filter((resolver4) => !resolver4.private);
 }
-__name(getModelLoadedResolvers, "getModelLoadedResolvers");
 
 // src/buildSchema/getType/index.ts
 function getGraphQLType(type, options) {
@@ -563,7 +540,7 @@ function getGraphQLType(type, options) {
     if (model.graphQLType) return model.graphQLType;
     model.graphQLType = new GraphQLObjectType({
       name: model.name,
-      fields: /* @__PURE__ */ __name(() => {
+      fields: () => {
         const fields = {};
         for (const field of getStaticFields(model)) {
           try {
@@ -585,30 +562,24 @@ function getGraphQLType(type, options) {
         }
         for (const resolver4 of getDynamicFields(model)) {
           try {
-            fields[resolver4.key] = getTypeAsResolver_default({
-              resolver: resolver4,
-              getGraphQLType,
-              options,
-              model
-            });
+            fields[resolver4.key] = getTypeAsResolver_default({ resolver: resolver4, getGraphQLType, options, model });
           } catch (error) {
-            throw new Error(`Error getting resolver type for resolver "${resolver4.key}": ${error.message}`);
+            throw new Error(
+              `Error getting resolver type for resolver "${resolver4.key}": ${error.message}`
+            );
           }
         }
         for (const resolver4 of getModelLoadedResolvers(model, options)) {
           try {
-            fields[resolver4.key] = getTypeAsResolver_default({
-              resolver: resolver4,
-              getGraphQLType,
-              options,
-              model
-            });
+            fields[resolver4.key] = getTypeAsResolver_default({ resolver: resolver4, getGraphQLType, options, model });
           } catch (error) {
-            throw new Error(`Error getting resolver type for resolver "${resolver4.key}": ${error.message}`);
+            throw new Error(
+              `Error getting resolver type for resolver "${resolver4.key}": ${error.message}`
+            );
           }
         }
         return fields;
-      }, "fields")
+      }
     });
     return model.graphQLType;
   } else {
@@ -617,7 +588,6 @@ function getGraphQLType(type, options) {
     return graphQLType;
   }
 }
-__name(getGraphQLType, "getGraphQLType");
 
 // src/buildSchema/getResolvers/resolversStore.ts
 var resolversStore = {};
@@ -644,12 +614,7 @@ async function getResolvers_default(options, mutation) {
           const result = await resolver4.resolve(params, context, info);
           return result;
         } catch (error) {
-          errorHandler(error, {
-            context,
-            resolver: resolver4,
-            options,
-            name
-          });
+          errorHandler(error, { context, resolver: resolver4, options, name });
           throw error;
         }
       }
@@ -657,7 +622,6 @@ async function getResolvers_default(options, mutation) {
   }
   return fields;
 }
-__name(getResolvers_default, "default");
 
 // src/buildSchema/getQuery.ts
 import isEmpty from "lodash/isEmpty";
@@ -669,7 +633,6 @@ async function getQuery_default(options) {
     fields
   });
 }
-__name(getQuery_default, "default");
 
 // src/buildSchema/getMutation.ts
 import { GraphQLObjectType as GraphQLObjectType3 } from "graphql";
@@ -682,7 +645,6 @@ async function getMutation_default(options) {
     fields
   });
 }
-__name(getMutation_default, "default");
 
 // src/buildSchema/getSubscription.ts
 import { GraphQLObjectType as GraphQLObjectType4 } from "graphql";
@@ -706,7 +668,6 @@ async function getSubscriptions_default(options) {
   }
   return fields;
 }
-__name(getSubscriptions_default, "default");
 
 // src/buildSchema/getSubscription.ts
 async function getSubscription_default(options) {
@@ -717,27 +678,19 @@ async function getSubscription_default(options) {
     fields
   });
 }
-__name(getSubscription_default, "default");
 
 // src/buildSchema/index.ts
 async function buildSchema_default(options) {
   const query = await getQuery_default(options);
   const mutation = await getMutation_default(options);
   const subscription = await getSubscription_default(options);
-  const schema = new GraphQLSchema({
-    query,
-    mutation,
-    subscription
-  });
+  const schema = new GraphQLSchema({ query, mutation, subscription });
   return schema;
 }
-__name(buildSchema_default, "default");
 
 // src/getApolloOptions/formatError.ts
 function formatError_default(apolloError) {
-  let response = {
-    ...apolloError
-  };
+  let response = { ...apolloError };
   const error = apolloError.originalError;
   if (error && error.isValidationError) {
     response.validationErrors = error.validationErrors;
@@ -747,7 +700,6 @@ function formatError_default(apolloError) {
   }
   return response;
 }
-__name(formatError_default, "default");
 
 // src/getApolloOptions/index.ts
 import { omit } from "lodash";
@@ -768,7 +720,6 @@ async function getApolloOptions_default(options) {
     formatError: formatError_default
   };
 }
-__name(getApolloOptions_default, "default");
 
 // src/startWebsocket.ts
 import { PubSub } from "graphql-subscriptions";
@@ -777,7 +728,7 @@ import { useServer } from "graphql-ws/lib/use/ws";
 
 // src/websockerViewer.ts
 global.getWebsocketViewerRef = () => null;
-var getWebsockerViewer = /* @__PURE__ */ __name(async (connectionParams) => {
+var getWebsockerViewer = async (connectionParams) => {
   try {
     const viewer = await global.getWebsocketViewerRef(connectionParams);
     if (!viewer) return {};
@@ -785,10 +736,10 @@ var getWebsockerViewer = /* @__PURE__ */ __name(async (connectionParams) => {
   } catch {
     return {};
   }
-}, "getWebsockerViewer");
-var setGetWebsockerViewer = /* @__PURE__ */ __name((getViewerFunc) => {
+};
+var setGetWebsockerViewer = (getViewerFunc) => {
   global.getWebsocketViewerRef = getViewerFunc;
-}, "setGetWebsockerViewer");
+};
 
 // src/startWebsocket.ts
 import { getServer } from "@orion-js/http";
@@ -804,12 +755,15 @@ function startWebsocket_default(apolloOptions, options, wsServer) {
       path: "/subscriptions"
     });
   }
-  const serverCleanup = useServer({
-    schema: apolloOptions.schema,
-    context: /* @__PURE__ */ __name(async (ctx, msg, args) => {
-      return getWebsockerViewer(ctx.connectionParams);
-    }, "context")
-  }, wsServer);
+  const serverCleanup = useServer(
+    {
+      schema: apolloOptions.schema,
+      context: async (ctx, msg, args) => {
+        return getWebsockerViewer(ctx.connectionParams);
+      }
+    },
+    wsServer
+  );
   return [
     // Proper shutdown for the WebSocket server.
     {
@@ -823,7 +777,6 @@ function startWebsocket_default(apolloOptions, options, wsServer) {
     }
   ];
 }
-__name(startWebsocket_default, "default");
 
 // src/startGraphQL.ts
 import { getApp, getServer as getServer2, registerRoute as registerRoute2, route as route2 } from "@orion-js/http";
@@ -838,36 +791,29 @@ async function startGraphQL_default(options) {
     startGraphiQL_default(apolloOptions, options);
   }
   const subPlugins = startWebsocket_default(apolloOptions, options);
-  const drainPlugins = httpServer ? [
-    ApolloServerPluginDrainHttpServer({
-      httpServer
-    })
-  ] : [];
+  const drainPlugins = httpServer ? [ApolloServerPluginDrainHttpServer({ httpServer })] : [];
   const server = new ApolloServer({
     ...apolloOptions,
-    plugins: [
-      ...apolloOptions.plugins || [],
-      ...drainPlugins,
-      ...subPlugins
-    ]
+    plugins: [...apolloOptions.plugins || [], ...drainPlugins, ...subPlugins]
   });
   await server.start();
   const middleware = expressMiddleware(server, {
     // @ts-expect-error
-    context: /* @__PURE__ */ __name(({ req, res }) => req._viewer, "context")
+    context: ({ req, res }) => req._viewer
   });
-  registerRoute2(route2({
-    app,
-    method: "all",
-    path: "/graphql",
-    bodyParser: "json",
-    async resolve(req, res, viewer) {
-      req._viewer = viewer;
-      return middleware(req, res, req.next);
-    }
-  }));
+  registerRoute2(
+    route2({
+      app,
+      method: "all",
+      path: "/graphql",
+      bodyParser: "json",
+      async resolve(req, res, viewer) {
+        req._viewer = viewer;
+        return middleware(req, res, req.next);
+      }
+    })
+  );
 }
-__name(startGraphQL_default, "default");
 
 // src/resolversSchemas/params.ts
 import { resolver as resolver2 } from "@orion-js/resolvers";
@@ -882,20 +828,12 @@ async function getParams2(field) {
   let { type } = field;
   if (typeof type === "function" && type.getModel && type.__schemaId) {
     const model = type.getModel();
-    return await getParams2({
-      ...field,
-      type: model
-    });
+    return await getParams2({ ...field, type: model });
   } else if (isArray3(type)) {
-    const serialized = await getParams2({
-      ...field,
-      type: type[0]
-    });
+    const serialized = await getParams2({ ...field, type: type[0] });
     return {
       ...serialized,
-      type: [
-        serialized.type
-      ],
+      type: [serialized.type],
       __graphQLType: `[${serialized.__graphQLType}]`
     };
   } else if (!type._isFieldType && (isPlainObject3(type) || type.__isModel)) {
@@ -920,7 +858,6 @@ async function getParams2(field) {
     };
   }
 }
-__name(getParams2, "getParams");
 
 // src/resolversSchemas/serializeSchema.ts
 async function serializeSchema(params) {
@@ -936,7 +873,6 @@ async function serializeSchema(params) {
   }
   return fields;
 }
-__name(serializeSchema, "serializeSchema");
 
 // src/resolversSchemas/getBasicResultQuery.ts
 import isArray4 from "lodash/isArray";
@@ -954,15 +890,14 @@ async function getBasicQuery(field) {
     return field.key;
   }
 }
-__name(getBasicQuery, "getBasicQuery");
 
 // src/resolversSchemas/ResolverParamsInfo.ts
 import { createModel } from "@orion-js/models";
 import { resolver } from "@orion-js/resolvers";
 import { isArray as isArray5 } from "lodash";
-var resolverReturnsIsModel = /* @__PURE__ */ __name((returns) => {
+var resolverReturnsIsModel = (returns) => {
   return returns && returns.__isModel;
-}, "resolverReturnsIsModel");
+};
 var ResolverParamsInfo_default = createModel({
   name: "ResolverParams",
   schema: {
@@ -973,26 +908,26 @@ var ResolverParamsInfo_default = createModel({
   resolvers: {
     params: resolver({
       returns: "blackbox",
-      resolve: /* @__PURE__ */ __name(async function({ resolver: resolver4 }) {
+      resolve: async function({ resolver: resolver4 }) {
         return await serializeSchema(resolver4.params);
-      }, "resolve")
+      }
     }),
     result: resolver({
       returns: String,
-      resolve: /* @__PURE__ */ __name(async function({ resolver: resolver4 }) {
+      resolve: async function({ resolver: resolver4 }) {
         const returns = isArray5(resolver4.returns) ? resolver4.returns[0] : resolver4.returns;
         if (resolverReturnsIsModel(returns)) return returns.name;
         return;
-      }, "resolve")
+      }
     }),
     basicResultQuery: resolver({
       returns: String,
-      resolve: /* @__PURE__ */ __name(async function({ resolver: resolver4 }) {
+      resolve: async function({ resolver: resolver4 }) {
         const returns = isArray5(resolver4.returns) ? resolver4.returns[0] : resolver4.returns;
         return await getBasicQuery({
           type: resolverReturnsIsModel(returns) ? returns.getSchema() : ""
         });
-      }, "resolve")
+      }
     })
   }
 });
@@ -1009,19 +944,19 @@ var params_default = resolver2({
   },
   returns: ResolverParamsInfo_default,
   mutation: false,
-  resolve: /* @__PURE__ */ __name(async function({ mutation, name }, viewer) {
+  resolve: async function({ mutation, name }, viewer) {
     const resolver4 = resolversStore[name];
     if (!resolver4) {
-      throw new UserError("notFound", `${mutation ? "Mutation" : "Query"} named "${name}" not found`);
+      throw new UserError(
+        "notFound",
+        `${mutation ? "Mutation" : "Query"} named "${name}" not found`
+      );
     }
     if (!!resolver4.mutation !== !!mutation) {
       throw new UserError("incorrectType", `"${name}" is ${mutation ? "not" : ""} a mutation`);
     }
-    return {
-      resolver: resolver4,
-      name
-    };
-  }, "resolve")
+    return { resolver: resolver4, name };
+  }
 });
 
 // src/resolversSchemas/index.ts
@@ -1033,15 +968,13 @@ var resolversSchemas_default = {
 import * as GraphQL2 from "graphql";
 
 // src/types/subscription.ts
-var _OrionSubscription = class _OrionSubscription {
+var OrionSubscription = class {
   name;
   params;
   subscribe;
   returns;
   publish;
 };
-__name(_OrionSubscription, "OrionSubscription");
-var OrionSubscription = _OrionSubscription;
 
 // src/service/global.ts
 import { getInstance, Service } from "@orion-js/services";
@@ -1063,12 +996,10 @@ function createRegisterResolverMetadata(metadataKey, isArray6 = false) {
     };
   };
 }
-__name(createRegisterResolverMetadata, "createRegisterResolverMetadata");
 function getTargetMetadata(target, propertyKey, metadataKey) {
   const items = target[metadataKey] || {};
   return items[propertyKey] || [];
 }
-__name(getTargetMetadata, "getTargetMetadata");
 var UseMiddleware = createRegisterResolverMetadata("middlewares", true);
 var ResolverParams = createRegisterResolverMetadata("params");
 var ResolverReturns = createRegisterResolverMetadata("returns");
@@ -1080,7 +1011,6 @@ function Resolvers() {
     target.prototype.service = target;
   };
 }
-__name(Resolvers, "Resolvers");
 function Query(options) {
   return (target, propertyKey, descriptor) => {
     if (!descriptor.value) throw new Error(`You must pass resolver function to ${propertyKey}`);
@@ -1091,14 +1021,13 @@ function Query(options) {
       returns: getTargetMetadata(target, propertyKey, "returns"),
       middlewares: getTargetMetadata(target, propertyKey, "middlewares"),
       ...options,
-      resolve: /* @__PURE__ */ __name(async (params, viewer, info) => {
+      resolve: async (params, viewer, info) => {
         const instance = getInstance(target.service);
         return await instance[propertyKey](params, viewer, info);
-      }, "resolve")
+      }
     });
   };
 }
-__name(Query, "Query");
 function Mutation(options) {
   return (target, propertyKey, descriptor) => {
     if (!descriptor.value) throw new Error(`You must pass resolver function to ${propertyKey}`);
@@ -1110,25 +1039,25 @@ function Mutation(options) {
       middlewares: getTargetMetadata(target, propertyKey, "middlewares"),
       ...options,
       mutation: true,
-      resolve: /* @__PURE__ */ __name(async (params, viewer, info) => {
+      resolve: async (params, viewer, info) => {
         const instance = getInstance(target.service);
         return await instance[propertyKey](params, viewer, info);
-      }, "resolve")
+      }
     });
   };
 }
-__name(Mutation, "Mutation");
 function getServiceResolvers(target) {
   if (!target.prototype) {
     throw new UserError2("You must pass a class to getResolvers");
   }
   return target.prototype.resolvers || {};
 }
-__name(getServiceResolvers, "getServiceResolvers");
 
 // src/service/model.ts
 import { getInstance as getInstance2, Service as Service2 } from "@orion-js/services";
-import { modelResolver } from "@orion-js/resolvers";
+import {
+  modelResolver
+} from "@orion-js/resolvers";
 import { UserError as UserError3 } from "@orion-js/helpers";
 function ModelResolver(options) {
   return (target, propertyKey, descriptor) => {
@@ -1139,14 +1068,13 @@ function ModelResolver(options) {
       returns: getTargetMetadata(target, propertyKey, "returns"),
       middlewares: getTargetMetadata(target, propertyKey, "middlewares"),
       ...options,
-      resolve: /* @__PURE__ */ __name(async (item, params, viewer, info) => {
+      resolve: async (item, params, viewer, info) => {
         const instance = getInstance2(target.service);
         return await instance[propertyKey](item, params, viewer, info);
-      }, "resolve")
+      }
     });
   };
 }
-__name(ModelResolver, "ModelResolver");
 function ModelResolvers(typedSchema, options = {}) {
   return (target) => {
     Service2()(target);
@@ -1159,7 +1087,6 @@ function ModelResolvers(typedSchema, options = {}) {
     target.getModel = () => getModelForClass(target);
   };
 }
-__name(ModelResolvers, "ModelResolvers");
 function getServiceModelResolvers(target) {
   if (!target.prototype) {
     throw new UserError3("You must pass a class to getResolvers");
@@ -1168,7 +1095,6 @@ function getServiceModelResolvers(target) {
     [target.prototype.modelName]: target.prototype.resolvers || {}
   };
 }
-__name(getServiceModelResolvers, "getServiceModelResolvers");
 
 // src/service/subscription.ts
 import { Container, Service as Service3 } from "@orion-js/services";
@@ -1180,7 +1106,6 @@ function Subscriptions() {
     target.prototype.serviceType = "subscriptions";
   };
 }
-__name(Subscriptions, "Subscriptions");
 function Subscription(options) {
   return (object, propertyName, index) => {
     const sub = subscription_default({
@@ -1193,23 +1118,23 @@ function Subscription(options) {
       object,
       propertyName,
       index,
-      value: /* @__PURE__ */ __name((_containerInstance) => {
+      value: (_containerInstance) => {
         if (!object.serviceType || object.serviceType !== "subscriptions") {
-          throw new Error("You must pass a class decorated with @Subscriptions if you want to use @Subscription");
+          throw new Error(
+            "You must pass a class decorated with @Subscriptions if you want to use @Subscription"
+          );
         }
         return sub;
-      }, "value")
+      }
     });
   };
 }
-__name(Subscription, "Subscription");
 function getServiceSubscriptions(target) {
   if (!target.prototype) {
     throw new UserError4("You must pass a class to getSubscriptions");
   }
   return target.prototype.subscriptions || {};
 }
-__name(getServiceSubscriptions, "getServiceSubscriptions");
 export {
   GraphQL2 as GraphQL,
   ModelResolver,