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

package/dist/index.cjs

@@ -4,7 +4,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -60,12 +59,12 @@ module.exports = __toCommonJS(index_exports);
 
 // 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
 var import_helpers = require("@orion-js/helpers");
@@ -74,29 +73,22 @@ function getChannelName_default(name, params) {
   const channelName = `${name}_${hash}`;
   return channelName;
 }
-__name(getChannelName_default, "default");
 
 // src/subscription/index.ts
 var import_resolvers = require("@orion-js/resolvers");
-var createSubscription = /* @__PURE__ */ __name(function(options) {
+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 (0, import_resolvers.checkPermissions)({
-        params,
-        viewer,
-        options: null
-      }, options);
+      await (0, import_resolvers.checkPermissions)({ params, viewer, options: null }, options);
       const channelName = getChannelName_default(subscription.name, params);
       return pubsub2.asyncIterator(channelName);
     } catch (error) {
@@ -106,7 +98,7 @@ var createSubscription = /* @__PURE__ */ __name(function(options) {
   subscription.params = (0, import_resolvers.cleanParams)(options.params);
   subscription.returns = (0, import_resolvers.cleanReturns)(options.returns);
   return subscription;
-}, "createSubscription");
+};
 var subscription_default = createSubscription;
 
 // src/startGraphiQL.ts
@@ -114,8 +106,7 @@ var import_http = require("@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";
@@ -296,19 +287,20 @@ var getHTML = /* @__PURE__ */ __name(function(apolloOptions, options, data) {
   </script>
 </body>
 </html>`;
-}, "getHTML");
+};
 function startGraphiQL_default(apolloOptions, options) {
-  (0, import_http.registerRoute)((0, import_http.route)({
-    path: "/graphiql",
-    method: "get",
-    async resolve(req) {
-      return {
-        body: getHTML(apolloOptions, options, req.query)
-      };
-    }
-  }));
+  (0, import_http.registerRoute)(
+    (0, import_http.route)({
+      path: "/graphiql",
+      method: "get",
+      async resolve(req) {
+        return {
+          body: getHTML(apolloOptions, options, req.query)
+        };
+      }
+    })
+  );
 }
-__name(startGraphiQL_default, "default");
 
 // src/buildSchema/index.ts
 var import_graphql10 = require("graphql");
@@ -326,7 +318,7 @@ var import_schema2 = require("@orion-js/schema");
 var import_graphql = require("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)");
   }
@@ -339,7 +331,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 import_graphql.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. ",
@@ -371,7 +363,6 @@ var import_graphql3 = require("graphql");
 function identity(value) {
   return value;
 }
-__name(identity, "identity");
 function parseLiteral(ast, variables) {
   switch (ast.kind) {
     case import_graphql3.Kind.STRING:
@@ -399,7 +390,6 @@ function parseLiteral(ast, variables) {
       return void 0;
   }
 }
-__name(parseLiteral, "parseLiteral");
 var JSONScalar_default = new import_graphql3.GraphQLScalarType({
   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).",
@@ -435,7 +425,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
 var import_isPlainObject = __toESM(require("lodash/isPlainObject"), 1);
@@ -456,11 +445,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];
   }
@@ -469,7 +457,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`);
@@ -493,7 +481,6 @@ function getParams(type) {
     return graphQLType;
   }
 }
-__name(getParams, "getParams");
 
 // src/buildSchema/getArgs/index.ts
 function getArgs_default(params) {
@@ -503,16 +490,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
 var import_crypto = __toESM(require("crypto"), 1);
@@ -546,7 +530,6 @@ function errorHandler(error, data) {
     });
   }
 }
-__name(errorHandler, "errorHandler");
 
 // src/buildSchema/getType/getTypeAsResolver.ts
 function getTypeAsResolver_default({ resolver: resolver4, getGraphQLType: getGraphQLType2, options, model }) {
@@ -560,18 +543,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) {
@@ -586,7 +563,6 @@ function getDynamicFields(model) {
     };
   }).filter((resolver4) => !resolver4.private);
 }
-__name(getDynamicFields, "getDynamicFields");
 
 // src/resolversSchemas/getModelLoadedResolvers.ts
 function getModelLoadedResolvers(model, options) {
@@ -602,7 +578,6 @@ function getModelLoadedResolvers(model, options) {
     };
   }).filter((resolver4) => !resolver4.private);
 }
-__name(getModelLoadedResolvers, "getModelLoadedResolvers");
 
 // src/buildSchema/getType/index.ts
 function getGraphQLType(type, options) {
@@ -620,7 +595,7 @@ function getGraphQLType(type, options) {
     if (model.graphQLType) return model.graphQLType;
     model.graphQLType = new import_graphql6.GraphQLObjectType({
       name: model.name,
-      fields: /* @__PURE__ */ __name(() => {
+      fields: () => {
         const fields = {};
         for (const field of getStaticFields(model)) {
           try {
@@ -642,30 +617,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 {
@@ -674,7 +643,6 @@ function getGraphQLType(type, options) {
     return graphQLType;
   }
 }
-__name(getGraphQLType, "getGraphQLType");
 
 // src/buildSchema/getResolvers/resolversStore.ts
 var resolversStore = {};
@@ -701,12 +669,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;
         }
       }
@@ -714,7 +677,6 @@ async function getResolvers_default(options, mutation) {
   }
   return fields;
 }
-__name(getResolvers_default, "default");
 
 // src/buildSchema/getQuery.ts
 var import_isEmpty = __toESM(require("lodash/isEmpty"), 1);
@@ -726,7 +688,6 @@ async function getQuery_default(options) {
     fields
   });
 }
-__name(getQuery_default, "default");
 
 // src/buildSchema/getMutation.ts
 var import_graphql8 = require("graphql");
@@ -739,7 +700,6 @@ async function getMutation_default(options) {
     fields
   });
 }
-__name(getMutation_default, "default");
 
 // src/buildSchema/getSubscription.ts
 var import_graphql9 = require("graphql");
@@ -763,7 +723,6 @@ async function getSubscriptions_default(options) {
   }
   return fields;
 }
-__name(getSubscriptions_default, "default");
 
 // src/buildSchema/getSubscription.ts
 async function getSubscription_default(options) {
@@ -774,27 +733,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 import_graphql10.GraphQLSchema({
-    query,
-    mutation,
-    subscription
-  });
+  const schema = new import_graphql10.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;
@@ -804,7 +755,6 @@ function formatError_default(apolloError) {
   }
   return response;
 }
-__name(formatError_default, "default");
 
 // src/getApolloOptions/index.ts
 var import_lodash = require("lodash");
@@ -825,7 +775,6 @@ async function getApolloOptions_default(options) {
     formatError: formatError_default
   };
 }
-__name(getApolloOptions_default, "default");
 
 // src/startWebsocket.ts
 var import_graphql_subscriptions = require("graphql-subscriptions");
@@ -834,7 +783,7 @@ var import_ws2 = require("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 {};
@@ -842,10 +791,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
 var import_http2 = require("@orion-js/http");
@@ -861,12 +810,15 @@ function startWebsocket_default(apolloOptions, options, wsServer) {
       path: "/subscriptions"
     });
   }
-  const serverCleanup = (0, import_ws2.useServer)({
-    schema: apolloOptions.schema,
-    context: /* @__PURE__ */ __name(async (ctx, msg, args) => {
-      return getWebsockerViewer(ctx.connectionParams);
-    }, "context")
-  }, wsServer);
+  const serverCleanup = (0, import_ws2.useServer)(
+    {
+      schema: apolloOptions.schema,
+      context: async (ctx, msg, args) => {
+        return getWebsockerViewer(ctx.connectionParams);
+      }
+    },
+    wsServer
+  );
   return [
     // Proper shutdown for the WebSocket server.
     {
@@ -880,7 +832,6 @@ function startWebsocket_default(apolloOptions, options, wsServer) {
     }
   ];
 }
-__name(startWebsocket_default, "default");
 
 // src/startGraphQL.ts
 var import_http3 = require("@orion-js/http");
@@ -895,36 +846,29 @@ async function startGraphQL_default(options) {
     startGraphiQL_default(apolloOptions, options);
   }
   const subPlugins = startWebsocket_default(apolloOptions, options);
-  const drainPlugins = httpServer ? [
-    (0, import_drainHttpServer.ApolloServerPluginDrainHttpServer)({
-      httpServer
-    })
-  ] : [];
+  const drainPlugins = httpServer ? [(0, import_drainHttpServer.ApolloServerPluginDrainHttpServer)({ httpServer })] : [];
   const server = new import_server.ApolloServer({
     ...apolloOptions,
-    plugins: [
-      ...apolloOptions.plugins || [],
-      ...drainPlugins,
-      ...subPlugins
-    ]
+    plugins: [...apolloOptions.plugins || [], ...drainPlugins, ...subPlugins]
   });
   await server.start();
   const middleware = (0, import_express4.expressMiddleware)(server, {
     // @ts-expect-error
-    context: /* @__PURE__ */ __name(({ req, res }) => req._viewer, "context")
+    context: ({ req, res }) => req._viewer
   });
-  (0, import_http3.registerRoute)((0, import_http3.route)({
-    app,
-    method: "all",
-    path: "/graphql",
-    bodyParser: "json",
-    async resolve(req, res, viewer) {
-      req._viewer = viewer;
-      return middleware(req, res, req.next);
-    }
-  }));
+  (0, import_http3.registerRoute)(
+    (0, import_http3.route)({
+      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
 var import_resolvers3 = require("@orion-js/resolvers");
@@ -939,20 +883,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 ((0, import_isArray3.default)(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 && ((0, import_isPlainObject3.default)(type) || type.__isModel)) {
@@ -977,7 +913,6 @@ async function getParams2(field) {
     };
   }
 }
-__name(getParams2, "getParams");
 
 // src/resolversSchemas/serializeSchema.ts
 async function serializeSchema(params) {
@@ -993,7 +928,6 @@ async function serializeSchema(params) {
   }
   return fields;
 }
-__name(serializeSchema, "serializeSchema");
 
 // src/resolversSchemas/getBasicResultQuery.ts
 var import_isArray4 = __toESM(require("lodash/isArray"), 1);
@@ -1011,15 +945,14 @@ async function getBasicQuery(field) {
     return field.key;
   }
 }
-__name(getBasicQuery, "getBasicQuery");
 
 // src/resolversSchemas/ResolverParamsInfo.ts
 var import_models = require("@orion-js/models");
 var import_resolvers2 = require("@orion-js/resolvers");
 var import_lodash2 = require("lodash");
-var resolverReturnsIsModel = /* @__PURE__ */ __name((returns) => {
+var resolverReturnsIsModel = (returns) => {
   return returns && returns.__isModel;
-}, "resolverReturnsIsModel");
+};
 var ResolverParamsInfo_default = (0, import_models.createModel)({
   name: "ResolverParams",
   schema: {
@@ -1030,26 +963,26 @@ var ResolverParamsInfo_default = (0, import_models.createModel)({
   resolvers: {
     params: (0, import_resolvers2.resolver)({
       returns: "blackbox",
-      resolve: /* @__PURE__ */ __name(async function({ resolver: resolver4 }) {
+      resolve: async function({ resolver: resolver4 }) {
         return await serializeSchema(resolver4.params);
-      }, "resolve")
+      }
     }),
     result: (0, import_resolvers2.resolver)({
       returns: String,
-      resolve: /* @__PURE__ */ __name(async function({ resolver: resolver4 }) {
+      resolve: async function({ resolver: resolver4 }) {
         const returns = (0, import_lodash2.isArray)(resolver4.returns) ? resolver4.returns[0] : resolver4.returns;
         if (resolverReturnsIsModel(returns)) return returns.name;
         return;
-      }, "resolve")
+      }
     }),
     basicResultQuery: (0, import_resolvers2.resolver)({
       returns: String,
-      resolve: /* @__PURE__ */ __name(async function({ resolver: resolver4 }) {
+      resolve: async function({ resolver: resolver4 }) {
         const returns = (0, import_lodash2.isArray)(resolver4.returns) ? resolver4.returns[0] : resolver4.returns;
         return await getBasicQuery({
           type: resolverReturnsIsModel(returns) ? returns.getSchema() : ""
         });
-      }, "resolve")
+      }
     })
   }
 });
@@ -1066,19 +999,19 @@ var params_default = (0, import_resolvers3.resolver)({
   },
   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 import_helpers2.UserError("notFound", `${mutation ? "Mutation" : "Query"} named "${name}" not found`);
+      throw new import_helpers2.UserError(
+        "notFound",
+        `${mutation ? "Mutation" : "Query"} named "${name}" not found`
+      );
     }
     if (!!resolver4.mutation !== !!mutation) {
       throw new import_helpers2.UserError("incorrectType", `"${name}" is ${mutation ? "not" : ""} a mutation`);
     }
-    return {
-      resolver: resolver4,
-      name
-    };
-  }, "resolve")
+    return { resolver: resolver4, name };
+  }
 });
 
 // src/resolversSchemas/index.ts
@@ -1090,15 +1023,13 @@ var resolversSchemas_default = {
 var GraphQL2 = __toESM(require("graphql"), 1);
 
 // 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
 var import_services = require("@orion-js/services");
@@ -1120,12 +1051,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");
@@ -1137,7 +1066,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}`);
@@ -1148,14 +1076,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 = (0, import_services.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}`);
@@ -1167,21 +1094,19 @@ 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 = (0, import_services.getInstance)(target.service);
         return await instance[propertyKey](params, viewer, info);
-      }, "resolve")
+      }
     });
   };
 }
-__name(Mutation, "Mutation");
 function getServiceResolvers(target) {
   if (!target.prototype) {
     throw new import_helpers3.UserError("You must pass a class to getResolvers");
   }
   return target.prototype.resolvers || {};
 }
-__name(getServiceResolvers, "getServiceResolvers");
 
 // src/service/model.ts
 var import_services2 = require("@orion-js/services");
@@ -1196,14 +1121,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 = (0, import_services2.getInstance)(target.service);
         return await instance[propertyKey](item, params, viewer, info);
-      }, "resolve")
+      }
     });
   };
 }
-__name(ModelResolver, "ModelResolver");
 function ModelResolvers(typedSchema, options = {}) {
   return (target) => {
     (0, import_services2.Service)()(target);
@@ -1216,7 +1140,6 @@ function ModelResolvers(typedSchema, options = {}) {
     target.getModel = () => getModelForClass(target);
   };
 }
-__name(ModelResolvers, "ModelResolvers");
 function getServiceModelResolvers(target) {
   if (!target.prototype) {
     throw new import_helpers4.UserError("You must pass a class to getResolvers");
@@ -1225,7 +1148,6 @@ function getServiceModelResolvers(target) {
     [target.prototype.modelName]: target.prototype.resolvers || {}
   };
 }
-__name(getServiceModelResolvers, "getServiceModelResolvers");
 
 // src/service/subscription.ts
 var import_services3 = require("@orion-js/services");
@@ -1237,7 +1159,6 @@ function Subscriptions() {
     target.prototype.serviceType = "subscriptions";
   };
 }
-__name(Subscriptions, "Subscriptions");
 function Subscription(options) {
   return (object, propertyName, index) => {
     const sub = subscription_default({
@@ -1250,23 +1171,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 import_helpers5.UserError("You must pass a class to getSubscriptions");
   }
   return target.prototype.subscriptions || {};
 }
-__name(getServiceSubscriptions, "getServiceSubscriptions");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GraphQL,