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

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";
@@ -260,16 +254,19 @@ import { GraphQLSchema } from "graphql";
 import { GraphQLObjectType as GraphQLObjectType2 } from "graphql";
 
 // src/buildSchema/getType/index.ts
-import isPlainObject2 from "lodash/isPlainObject";
 import isArray2 from "lodash/isArray";
 import { GraphQLList as GraphQLList2, GraphQLObjectType } from "graphql";
-import { getFieldType as getFieldType2 } from "@orion-js/schema";
+import {
+  getFieldType as getFieldType2,
+  getSchemaWithMetadataFromAnyOrionForm,
+  isSchemaLike
+} from "@orion-js/schema";
 
 // src/buildSchema/getType/BigIntScalar.ts
 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 +279,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 +311,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 +338,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 +373,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";
@@ -387,9 +381,11 @@ import { GraphQLList, GraphQLInputObjectType } from "graphql";
 import { getFieldType } from "@orion-js/schema";
 
 // src/resolversSchemas/getStaticFields.ts
-function getStaticFields(model) {
-  const schema = model.getSchema();
+function getStaticFields(schema) {
   if (!schema) return [];
+  if (schema.getSchema) {
+    schema = schema.getSchema();
+  }
   const keys = Object.keys(schema).filter((key) => !key.startsWith("__"));
   return keys.map((key) => {
     const field = schema[key];
@@ -399,72 +395,75 @@ function getStaticFields(model) {
     };
   }).filter((field) => !field.private);
 }
-__name(getStaticFields, "getStaticFields");
 
 // src/buildSchema/getArgs/getField.ts
+Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
 var storedModelInput = {};
-var getModelInput = /* @__PURE__ */ __name(function(model, fields) {
-  if (storedModelInput[model.name]) {
-    return storedModelInput[model.name];
+var getCachedModelInput = (model, fields) => {
+  if (!storedModelInput[model.name]) {
+    storedModelInput[model.name] = new GraphQLInputObjectType({
+      name: `${model.name}Input`,
+      fields
+    });
   }
-  storedModelInput[model.name] = new GraphQLInputObjectType({
-    name: model.name + "Input",
-    fields
-  });
   return storedModelInput[model.name];
-}, "getModelInput");
-function getParams(type) {
-  if (!type) {
-    throw new Error(`No type specified`);
+};
+var resolveModelFields = (model) => {
+  const fields = {};
+  for (const field of getStaticFields(model)) {
+    fields[field.key] = { type: resolveType(field.type) };
   }
-  if (isArray(type)) {
-    const graphQLType = getParams(type[0]);
-    return new GraphQLList(graphQLType);
-  } else if (!type._isFieldType && (isPlainObject(type) || type.__isModel)) {
-    const model = type.__isModel ? type : type.__model;
-    if (!model || !model.__isModel) throw new Error(`A type is not a Model`);
-    const fields = {};
-    for (const field of getStaticFields(model)) {
-      fields[field.key] = {
-        type: getParams(field.type)
-      };
-    }
-    return getModelInput(model, fields);
-  } else {
-    const schemaType = getFieldType(type);
-    const graphQLType = getScalar_default(schemaType);
-    return graphQLType;
+  return fields;
+};
+var resolveArrayType = (type) => new GraphQLList(resolveType(type[0]));
+var resolvePlainObjectOrModelType = (type) => {
+  const model = type.__isModel ? type : type.__model;
+  if (!model || !model.__isModel) {
+    throw new Error("A type is not a Model");
   }
-}
-__name(getParams, "getParams");
+  const fields = resolveModelFields(model);
+  return getCachedModelInput(model, fields);
+};
+var resolveType = (type) => {
+  var _a;
+  if (!type) throw new Error("No type specified");
+  if ((_a = type == null ? void 0 : type[Symbol.metadata]) == null ? void 0 : _a._getModel) {
+    const model = type[Symbol.metadata]._getModel();
+    return resolveType(model);
+  }
+  if (isArray(type)) return resolveArrayType(type);
+  if (!type.__isFieldType && (isPlainObject(type) || type.__isModel)) {
+    return resolvePlainObjectOrModelType(type);
+  }
+  const schemaType = getFieldType(type);
+  return getScalar_default(schemaType);
+};
+var getField_default = resolveType;
 
 // src/buildSchema/getArgs/index.ts
-function getArgs_default(params) {
+async function getArgs_default(params) {
   if (!params) return;
   if (Object.keys(params).length === 0) return;
   const fields = {};
   for (const key of Object.keys(params)) {
     try {
-      const type = getParams(params[key].type);
-      fields[key] = {
-        type
-      };
+      const type = getField_default(params[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";
 import { GraphQLError } from "graphql";
 function errorHandler(error, data) {
-  const message = `Error in resolver "${data.name}" ${data.model ? `of model "${data.model.name}"` : ""}`;
+  const message = `Error in resolver "${data.name}" ${data.schema ? `of model "${data.schema.__modelName}"` : ""}`;
   const hash = crypto.createHash("sha1").update(error.message, "utf8").digest("hex").substring(0, 10);
   error.hash = hash;
-  if (error && error.isOrionError) {
+  if (error == null ? void 0 : error.isOrionError) {
     console.warn(message, error);
     throw new GraphQLError(error.message, {
       originalError: error,
@@ -476,148 +475,151 @@ function errorHandler(error, data) {
         info: error.getInfo()
       }
     });
-  } else {
-    console.error(message, error);
-    throw new GraphQLError(`${error.message} [${hash}]`, {
-      // originalError: error,
-      extensions: {
-        isOrionError: false,
-        isValidationError: false,
-        code: "INTERNAL_SERVER_ERROR",
-        hash
-      }
-    });
   }
+  console.error(message, error);
+  throw new GraphQLError(`${error.message} [${hash}]`, {
+    // originalError: error,
+    extensions: {
+      isOrionError: false,
+      isValidationError: false,
+      code: "INTERNAL_SERVER_ERROR",
+      hash
+    }
+  });
 }
-__name(errorHandler, "errorHandler");
 
 // src/buildSchema/getType/getTypeAsResolver.ts
-function getTypeAsResolver_default({ resolver: resolver4, getGraphQLType: getGraphQLType2, options, model }) {
-  const type = getGraphQLType2(resolver4.returns, options);
-  const args = getArgs_default(resolver4.params);
+function getTypeAsResolver_default({ resolver: resolver2, getGraphQLType: getGraphQLType2, options, schema }) {
+  const type = getGraphQLType2(resolver2.returns, options);
+  const args = getArgs_default(resolver2.params);
   return {
     type,
     args,
     async resolve(item, params, context, info) {
       try {
-        const result = await resolver4.resolve(item, params, context, info);
+        const result = await resolver2.resolve(item, params, context, info);
         return result;
       } catch (error) {
-        errorHandler(error, {
-          context,
-          resolver: resolver4,
-          options,
-          model
-        });
+        errorHandler(error, { context, resolver: resolver2, options, schema });
         throw error;
       }
     }
   };
 }
-__name(getTypeAsResolver_default, "default");
 
 // src/resolversSchemas/getDynamicFields.ts
-function getDynamicFields(model) {
-  const resolvers = model.getResolvers();
+function getResolvers(schema) {
+  if (typeof schema.getResolvers === "function") {
+    console.warn("Models are deprecated");
+    return schema.getResolvers();
+  }
+  if (schema.__resolvers) {
+    return schema.__resolvers;
+  }
+  return {};
+}
+function getDynamicFields(schema) {
+  const resolvers = getResolvers(schema);
   if (!resolvers) return [];
   const keys = Object.keys(resolvers);
   return keys.map((key) => {
-    const resolver4 = resolvers[key];
+    const resolver2 = resolvers[key];
     return {
-      ...resolver4,
+      ...resolver2,
       key
     };
-  }).filter((resolver4) => !resolver4.private);
+  }).filter((resolver2) => !resolver2.private);
 }
-__name(getDynamicFields, "getDynamicFields");
 
 // src/resolversSchemas/getModelLoadedResolvers.ts
-function getModelLoadedResolvers(model, options) {
+function getModelLoadedResolvers(schema, options) {
   if (!options.modelResolvers) return [];
-  const resolvers = options.modelResolvers[model.name];
+  const resolvers = options.modelResolvers[schema.__modelName];
   if (!resolvers) return [];
   const keys = Object.keys(resolvers);
   return keys.map((key) => {
-    const resolver4 = resolvers[key];
+    const resolver2 = resolvers[key];
     return {
-      ...resolver4,
+      ...resolver2,
       key
     };
-  }).filter((resolver4) => !resolver4.private);
+  }).filter((resolver2) => !resolver2.private);
 }
-__name(getModelLoadedResolvers, "getModelLoadedResolvers");
 
 // src/buildSchema/getType/index.ts
+import { isEqual } from "lodash";
+var createGraphQLObjectType = (modelName, schema, options) => new GraphQLObjectType({
+  name: modelName,
+  fields: () => buildFields(schema, options)
+});
+var buildFields = (schema, options) => {
+  const fields = {};
+  const addStaticFields = () => {
+    for (const field of getStaticFields(schema)) {
+      try {
+        fields[field.key] = field.graphQLResolver ? getTypeAsResolver_default({ resolver: field.graphQLResolver, getGraphQLType, options, schema }) : { type: getGraphQLType(field.type, options) };
+      } catch (error) {
+        throw new Error(`Error getting type for ${field.key}: ${error.message}`);
+      }
+    }
+  };
+  const addDynamicFields = () => {
+    for (const resolver2 of getDynamicFields(schema)) {
+      try {
+        fields[resolver2.key] = getTypeAsResolver_default({ resolver: resolver2, getGraphQLType, options, schema });
+      } catch (error) {
+        throw new Error(
+          `Error getting resolver type for resolver "${resolver2.key}": ${error.message}`
+        );
+      }
+    }
+  };
+  const addModelLoadedResolvers = () => {
+    for (const resolver2 of getModelLoadedResolvers(schema, options)) {
+      try {
+        fields[resolver2.key] = getTypeAsResolver_default({ resolver: resolver2, getGraphQLType, options, schema });
+      } catch (error) {
+        throw new Error(
+          `Error getting resolver type for resolver "${resolver2.key}": ${error.message}`
+        );
+      }
+    }
+  };
+  addStaticFields();
+  addDynamicFields();
+  addModelLoadedResolvers();
+  return fields;
+};
+var registeredGraphQLTypes = /* @__PURE__ */ new Map();
 function getGraphQLType(type, options) {
-  if (!type) {
-    throw new Error("Type is undefined");
-  }
+  if (!type) throw new Error("Type is undefined");
   if (isArray2(type)) {
-    const graphQLType = getGraphQLType(type[0], options);
-    return new GraphQLList2(graphQLType);
-  } else if (typeof type === "function" && type.getModel && type.__schemaId) {
-    return getGraphQLType(type.getModel(), options);
-  } else if (!type._isFieldType && (isPlainObject2(type) || type.__isModel)) {
-    const model = type.__isModel ? type : type.__model;
-    if (!model || !model.__isModel) throw new Error("Type is not a Model");
-    if (model.graphQLType) return model.graphQLType;
-    model.graphQLType = new GraphQLObjectType({
-      name: model.name,
-      fields: /* @__PURE__ */ __name(() => {
-        const fields = {};
-        for (const field of getStaticFields(model)) {
-          try {
-            if (field.graphQLResolver) {
-              fields[field.key] = getTypeAsResolver_default({
-                resolver: field.graphQLResolver,
-                getGraphQLType,
-                options,
-                model
-              });
-            } else {
-              fields[field.key] = {
-                type: getGraphQLType(field.type, options)
-              };
-            }
-          } catch (error) {
-            throw new Error(`Error getting type for ${field.key} ${error.message}`);
-          }
-        }
-        for (const resolver4 of getDynamicFields(model)) {
-          try {
-            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}`);
-          }
-        }
-        for (const resolver4 of getModelLoadedResolvers(model, options)) {
-          try {
-            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}`);
-          }
-        }
-        return fields;
-      }, "fields")
-    });
-    return model.graphQLType;
-  } else {
-    const schemaType = getFieldType2(type);
-    const graphQLType = getScalar_default(schemaType);
+    return new GraphQLList2(getGraphQLType(type[0], options));
+  }
+  if (isSchemaLike(type)) {
+    const schema = getSchemaWithMetadataFromAnyOrionForm(type);
+    const modelName = schema.__modelName;
+    if (schema.__graphQLType) {
+      return schema.__graphQLType;
+    }
+    if (!modelName) {
+      throw new Error(
+        `Schema name is not defined. Register a name with schemaWithName. Schema: ${JSON.stringify(schema)}`
+      );
+    }
+    if (registeredGraphQLTypes.has(modelName)) {
+      const { graphQLType: graphQLType2, schema: registeredSchema } = registeredGraphQLTypes.get(modelName);
+      if (isEqual(registeredSchema, schema)) {
+        return graphQLType2;
+      }
+      throw new Error(`Schema named "${modelName}" already registered`);
+    }
+    const graphQLType = createGraphQLObjectType(modelName, schema, options);
+    registeredGraphQLTypes.set(modelName, { schema, graphQLType });
     return graphQLType;
   }
+  return getScalar_default(getFieldType2(type));
 }
-__name(getGraphQLType, "getGraphQLType");
 
 // src/buildSchema/getResolvers/resolversStore.ts
 var resolversStore = {};
@@ -630,26 +632,21 @@ async function getResolvers_default(options, mutation) {
       name: key,
       resolver: resolvers[key]
     };
-  }).filter(({ resolver: resolver4 }) => !!resolver4.mutation === !!mutation).filter(({ resolver: resolver4 }) => !resolver4.private);
+  }).filter(({ resolver: resolver2 }) => !!resolver2.mutation === !!mutation).filter(({ resolver: resolver2 }) => !resolver2.private);
   const fields = {};
-  for (const { resolver: resolver4, name } of filteredResolvers) {
-    resolversStore[name] = resolver4;
-    const type = await getGraphQLType(resolver4.returns, options);
-    const args = await getArgs_default(resolver4.params);
+  for (const { resolver: resolver2, name } of filteredResolvers) {
+    resolversStore[name] = resolver2;
+    const type = await getGraphQLType(resolver2.returns, options);
+    const args = await getArgs_default(resolver2.params);
     fields[name] = {
       type,
       args,
-      async resolve(root, params, context, info) {
+      async resolve(_root, params, context, info) {
         try {
-          const result = await resolver4.resolve(params, context, info);
+          const result = await resolver2.resolve(params, context, info);
           return result;
         } catch (error) {
-          errorHandler(error, {
-            context,
-            resolver: resolver4,
-            options,
-            name
-          });
+          errorHandler(error, { context, resolver: resolver2, options, name });
           throw error;
         }
       }
@@ -657,7 +654,6 @@ async function getResolvers_default(options, mutation) {
   }
   return fields;
 }
-__name(getResolvers_default, "default");
 
 // src/buildSchema/getQuery.ts
 import isEmpty from "lodash/isEmpty";
@@ -669,7 +665,6 @@ async function getQuery_default(options) {
     fields
   });
 }
-__name(getQuery_default, "default");
 
 // src/buildSchema/getMutation.ts
 import { GraphQLObjectType as GraphQLObjectType3 } from "graphql";
@@ -682,7 +677,6 @@ async function getMutation_default(options) {
     fields
   });
 }
-__name(getMutation_default, "default");
 
 // src/buildSchema/getSubscription.ts
 import { GraphQLObjectType as GraphQLObjectType4 } from "graphql";
@@ -706,7 +700,6 @@ async function getSubscriptions_default(options) {
   }
   return fields;
 }
-__name(getSubscriptions_default, "default");
 
 // src/buildSchema/getSubscription.ts
 async function getSubscription_default(options) {
@@ -717,27 +710,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 +732,6 @@ function formatError_default(apolloError) {
   }
   return response;
 }
-__name(formatError_default, "default");
 
 // src/getApolloOptions/index.ts
 import { omit } from "lodash";
@@ -768,7 +752,6 @@ async function getApolloOptions_default(options) {
     formatError: formatError_default
   };
 }
-__name(getApolloOptions_default, "default");
 
 // src/startWebsocket.ts
 import { PubSub } from "graphql-subscriptions";
@@ -777,7 +760,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 +768,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 +787,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 +809,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,167 +823,156 @@ 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";
+import { createResolver } from "@orion-js/resolvers";
 import { UserError } from "@orion-js/helpers";
 
+// src/resolversSchemas/ResolverParamsInfo.ts
+import { schemaWithName } from "@orion-js/schema";
+var ResolverParamsInfo_default = schemaWithName("ResolverParams", {
+  name: {
+    type: "string"
+  },
+  params: {
+    type: "blackbox"
+  },
+  result: {
+    type: "string"
+  },
+  basicResultQuery: {
+    type: "string"
+  }
+});
+
+// src/resolversSchemas/serializeSchema.ts
+import { getSchemaFromAnyOrionForm } from "@orion-js/schema";
+
 // src/resolversSchemas/getField.ts
-import isPlainObject3 from "lodash/isPlainObject";
-import isArray3 from "lodash/isArray";
-import { getFieldType as getFieldType3 } from "@orion-js/schema";
+import {
+  getFieldType as getFieldType3,
+  getSchemaWithMetadataFromAnyOrionForm as getSchemaWithMetadataFromAnyOrionForm2,
+  isSchemaLike as isSchemaLike2
+} from "@orion-js/schema";
 import omit2 from "lodash/omit";
-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
-    });
-  } else if (isArray3(type)) {
-    const serialized = await getParams2({
-      ...field,
-      type: type[0]
-    });
+async function getParams(field) {
+  const { type } = field;
+  if (Array.isArray(type)) {
+    const serialized = await getParams({ ...field, type: type[0] });
     return {
       ...serialized,
-      type: [
-        serialized.type
-      ],
+      type: [serialized.type],
       __graphQLType: `[${serialized.__graphQLType}]`
     };
-  } else if (!type._isFieldType && (isPlainObject3(type) || type.__isModel)) {
-    const model = type.__isModel ? type : type.__model;
-    if (!model || !model.__isModel) throw new Error("Type is not a Model");
+  }
+  const isSchema = isSchemaLike2(type);
+  if (isSchema) {
+    const schemaOfType = getSchemaWithMetadataFromAnyOrionForm2(type);
+    const modelName = schemaOfType.__modelName;
+    if (!modelName) {
+      throw new Error("The schema needs a model name to be serialized for GraphQL");
+    }
     const fields = {};
-    for (const field2 of getStaticFields(model)) {
-      fields[field2.key] = await getParams2(field2);
+    for (const field2 of getStaticFields(schemaOfType)) {
+      fields[field2.key] = await getParams(field2);
     }
     return {
       ...omit2(field, "key"),
       type: fields,
-      __graphQLType: model.name + "Input"
-    };
-  } else {
-    const schemaType = await getFieldType3(type);
-    const graphQLType = await getScalar_default(schemaType);
-    return {
-      ...omit2(field, "key"),
-      type: schemaType.name,
-      __graphQLType: graphQLType.name
+      __graphQLType: `${modelName}Input`
     };
   }
+  const schemaType = getFieldType3(type);
+  const graphQLType = await getScalar_default(schemaType);
+  return {
+    ...omit2(field, "key"),
+    type: schemaType.name,
+    __graphQLType: graphQLType.name
+  };
 }
-__name(getParams2, "getParams");
 
 // src/resolversSchemas/serializeSchema.ts
+Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
 async function serializeSchema(params) {
   if (!params) return;
-  if (typeof params === "function" && params.getModel && params.__schemaId) {
-    params = params.getModel().getCleanSchema();
-  }
-  if (Object.keys(params).length === 0) return;
+  const schema = getSchemaFromAnyOrionForm(params);
+  if (Object.keys(schema).length === 0) return;
   const fields = {};
-  for (const key of Object.keys(params)) {
-    const field = params[key];
-    fields[key] = await getParams2(field);
+  for (const key of Object.keys(schema).filter((key2) => !key2.startsWith("__"))) {
+    const field = schema[key];
+    fields[key] = await getParams(field);
   }
   return fields;
 }
-__name(serializeSchema, "serializeSchema");
+
+// src/resolversSchemas/params.ts
+import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm3, isSchemaLike as isSchemaLike4 } from "@orion-js/schema";
 
 // src/resolversSchemas/getBasicResultQuery.ts
-import isArray4 from "lodash/isArray";
+import isArray3 from "lodash/isArray";
+import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm2, isSchemaLike as isSchemaLike3 } from "@orion-js/schema";
 async function getBasicQuery(field) {
   if (!field.type) return "";
-  if (isArray4(field.type) && field.type[0].__model || field.type.__model) {
-    const model = isArray4(field.type) ? field.type[0].__model : field.type.__model;
-    const fields = [];
-    for (const field2 of getStaticFields(model)) {
-      fields.push(await getBasicQuery(field2));
-    }
-    const key = field.key ? `${field.key} ` : "";
-    return `${key}{ ${fields.join(" ")} }`;
-  } else {
+  if (isArray3(field.type)) {
+    return getBasicQuery({
+      ...field,
+      type: field.type[0]
+    });
+  }
+  if (!isSchemaLike3(field.type)) {
     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) => {
-  return returns && returns.__isModel;
-}, "resolverReturnsIsModel");
-var ResolverParamsInfo_default = createModel({
-  name: "ResolverParams",
-  schema: {
-    name: {
-      type: String
-    }
-  },
-  resolvers: {
-    params: resolver({
-      returns: "blackbox",
-      resolve: /* @__PURE__ */ __name(async function({ resolver: resolver4 }) {
-        return await serializeSchema(resolver4.params);
-      }, "resolve")
-    }),
-    result: resolver({
-      returns: String,
-      resolve: /* @__PURE__ */ __name(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 }) {
-        const returns = isArray5(resolver4.returns) ? resolver4.returns[0] : resolver4.returns;
-        return await getBasicQuery({
-          type: resolverReturnsIsModel(returns) ? returns.getSchema() : ""
-        });
-      }, "resolve")
-    })
+  const schema = getSchemaFromAnyOrionForm2(field.type);
+  const fields = [];
+  for (const field2 of getStaticFields(schema)) {
+    fields.push(await getBasicQuery(field2));
   }
-});
+  const key = field.key ? `${field.key} ` : "";
+  return `${key}{ ${fields.join(" ")} }`;
+}
 
 // src/resolversSchemas/params.ts
-var params_default = resolver2({
+function getResultTypeName(type) {
+  const returns = Array.isArray(type) ? type[0] : type;
+  const schema = getSchemaFromAnyOrionForm3(returns);
+  if (schema == null ? void 0 : schema.__modelName) return schema.__modelName;
+  return;
+}
+async function getInternalBasicResultQuery(type) {
+  const returns = Array.isArray(type) ? type[0] : type;
+  if (isSchemaLike4(returns)) {
+    const schema = getSchemaFromAnyOrionForm3(returns);
+    return await getBasicQuery({
+      type: schema
+    });
+  }
+  return "";
+}
+var params_default = createResolver({
   params: {
     name: {
       type: "ID"
@@ -1009,19 +983,24 @@ var params_default = resolver2({
   },
   returns: ResolverParamsInfo_default,
   mutation: false,
-  resolve: /* @__PURE__ */ __name(async function({ mutation, name }, viewer) {
-    const resolver4 = resolversStore[name];
-    if (!resolver4) {
-      throw new UserError("notFound", `${mutation ? "Mutation" : "Query"} named "${name}" not found`);
+  async resolve({ mutation, name }) {
+    const resolver2 = resolversStore[name];
+    if (!resolver2) {
+      throw new UserError(
+        "notFound",
+        `${mutation ? "Mutation" : "Query"} named "${name}" not found`
+      );
     }
-    if (!!resolver4.mutation !== !!mutation) {
+    if (!!resolver2.mutation !== !!mutation) {
       throw new UserError("incorrectType", `"${name}" is ${mutation ? "not" : ""} a mutation`);
     }
     return {
-      resolver: resolver4,
-      name
+      name,
+      basicResultQuery: await getInternalBasicResultQuery(resolver2.returns),
+      params: await serializeSchema(resolver2.params),
+      result: getResultTypeName(resolver2.returns)
     };
-  }, "resolve")
+  }
 });
 
 // src/resolversSchemas/index.ts
@@ -1033,183 +1012,224 @@ 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";
-import { resolver as resolver3 } from "@orion-js/resolvers";
-import { UserError as UserError2 } from "@orion-js/helpers";
+import { resolver } from "@orion-js/resolvers";
 
-// src/service/otherParams.ts
-function createRegisterResolverMetadata(metadataKey, isArray6 = false) {
-  return (metadata) => {
-    return (target, propertyKey, descriptor) => {
-      if (!descriptor.value) throw new Error(`You must pass resolver function to ${propertyKey}`);
-      target[metadataKey] = target[metadataKey] || {};
-      if (isArray6) {
-        target[metadataKey][propertyKey] = target[metadataKey][propertyKey] || [];
-        target[metadataKey][propertyKey].unshift(metadata);
-      } else {
-        target[metadataKey][propertyKey] = metadata;
-      }
-    };
-  };
+// src/service/middlewares.ts
+var resolversMetadata = /* @__PURE__ */ new WeakMap();
+function addTargetMetadata(target, propertyKey, metadataKey, metadata, isArray4 = false) {
+  const targetMetadata = resolversMetadata.get(target) || {};
+  targetMetadata[propertyKey] = targetMetadata[propertyKey] || {};
+  if (isArray4) {
+    targetMetadata[propertyKey][metadataKey] = targetMetadata[propertyKey][metadataKey] || [];
+    targetMetadata[propertyKey][metadataKey].unshift(metadata);
+  } else {
+    targetMetadata[propertyKey][metadataKey] = metadata;
+  }
+  resolversMetadata.set(target, targetMetadata);
 }
-__name(createRegisterResolverMetadata, "createRegisterResolverMetadata");
 function getTargetMetadata(target, propertyKey, metadataKey) {
-  const items = target[metadataKey] || {};
-  return items[propertyKey] || [];
+  var _a;
+  const targetMetadata = resolversMetadata.get(target) || {};
+  return (_a = targetMetadata[propertyKey]) == null ? void 0 : _a[metadataKey];
+}
+function UseMiddleware(params) {
+  return (method, context) => {
+    const propertyKey = String(context.name);
+    addTargetMetadata(method, propertyKey, "middlewares", params, true);
+    return method;
+  };
+}
+function ResolverParams(params) {
+  return (method, context) => {
+    const propertyKey = String(context.name);
+    addTargetMetadata(method, propertyKey, "params", params, false);
+    return method;
+  };
+}
+function ResolverReturns(returns) {
+  return (method, context) => {
+    const propertyKey = String(context.name);
+    addTargetMetadata(method, propertyKey, "returns", returns, false);
+    return method;
+  };
 }
-__name(getTargetMetadata, "getTargetMetadata");
-var UseMiddleware = createRegisterResolverMetadata("middlewares", true);
-var ResolverParams = createRegisterResolverMetadata("params");
-var ResolverReturns = createRegisterResolverMetadata("returns");
 
 // src/service/global.ts
+var serviceMetadata = /* @__PURE__ */ new WeakMap();
+var resolversMetadata2 = /* @__PURE__ */ new WeakMap();
 function Resolvers() {
-  return (target) => {
-    Service()(target);
-    target.prototype.service = target;
+  return (target, context) => {
+    Service()(target, context);
+    context.addInitializer(function() {
+      serviceMetadata.set(this, { _serviceType: "resolvers" });
+    });
   };
 }
-__name(Resolvers, "Resolvers");
-function Query(options) {
-  return (target, propertyKey, descriptor) => {
-    if (!descriptor.value) throw new Error(`You must pass resolver function to ${propertyKey}`);
-    target.resolvers = target.resolvers || {};
-    target.resolvers[propertyKey] = resolver3({
-      resolverId: propertyKey,
-      params: getTargetMetadata(target, propertyKey, "params"),
-      returns: getTargetMetadata(target, propertyKey, "returns"),
-      middlewares: getTargetMetadata(target, propertyKey, "middlewares"),
-      ...options,
-      resolve: /* @__PURE__ */ __name(async (params, viewer, info) => {
-        const instance = getInstance(target.service);
-        return await instance[propertyKey](params, viewer, info);
-      }, "resolve")
+function Query(options = {}) {
+  return (method, context) => {
+    const propertyKey = String(context.name);
+    context.addInitializer(function() {
+      const resolvers = resolversMetadata2.get(this) || {};
+      resolvers[propertyKey] = resolver({
+        resolverId: propertyKey,
+        params: getTargetMetadata(method, propertyKey, "params") || {},
+        returns: getTargetMetadata(method, propertyKey, "returns") || "string",
+        middlewares: getTargetMetadata(method, propertyKey, "middlewares") || [],
+        ...options,
+        resolve: this[propertyKey].bind(this)
+      });
+      resolversMetadata2.set(this, resolvers);
     });
+    return method;
   };
 }
-__name(Query, "Query");
 function Mutation(options) {
-  return (target, propertyKey, descriptor) => {
-    if (!descriptor.value) throw new Error(`You must pass resolver function to ${propertyKey}`);
-    target.resolvers = target.resolvers || {};
-    target.resolvers[propertyKey] = resolver3({
-      resolverId: propertyKey,
-      params: getTargetMetadata(target, propertyKey, "params"),
-      returns: getTargetMetadata(target, propertyKey, "returns"),
-      middlewares: getTargetMetadata(target, propertyKey, "middlewares"),
-      ...options,
-      mutation: true,
-      resolve: /* @__PURE__ */ __name(async (params, viewer, info) => {
-        const instance = getInstance(target.service);
-        return await instance[propertyKey](params, viewer, info);
-      }, "resolve")
+  return (method, context) => {
+    const propertyKey = String(context.name);
+    context.addInitializer(function() {
+      const resolvers = resolversMetadata2.get(this) || {};
+      resolvers[propertyKey] = resolver({
+        resolverId: propertyKey,
+        params: getTargetMetadata(method, propertyKey, "params") || {},
+        returns: getTargetMetadata(method, propertyKey, "returns") || "string",
+        middlewares: getTargetMetadata(method, propertyKey, "middlewares") || [],
+        ...options,
+        mutation: true,
+        resolve: this[propertyKey].bind(this)
+      });
+      resolversMetadata2.set(this, resolvers);
     });
+    return method;
   };
 }
-__name(Mutation, "Mutation");
 function getServiceResolvers(target) {
-  if (!target.prototype) {
-    throw new UserError2("You must pass a class to getResolvers");
+  const instance = getInstance(target);
+  if (!serviceMetadata.has(instance.constructor)) {
+    throw new Error("You must pass a class decorated with @Resolvers to getServiceResolvers");
+  }
+  const instanceMetadata = serviceMetadata.get(instance.constructor);
+  if (instanceMetadata._serviceType !== "resolvers") {
+    throw new Error("You must pass a class decorated with @Resolvers to getServiceResolvers");
   }
-  return target.prototype.resolvers || {};
+  const resolversMap = resolversMetadata2.get(instance) || {};
+  return resolversMap;
 }
-__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 { UserError as UserError3 } from "@orion-js/helpers";
-function ModelResolver(options) {
-  return (target, propertyKey, descriptor) => {
-    if (!descriptor.value) throw new Error(`You must pass resolver function to ${propertyKey}`);
-    target.resolvers = target.resolvers || {};
-    target.resolvers[propertyKey] = modelResolver({
-      params: getTargetMetadata(target, propertyKey, "params"),
-      returns: getTargetMetadata(target, propertyKey, "returns"),
-      middlewares: getTargetMetadata(target, propertyKey, "middlewares"),
-      ...options,
-      resolve: /* @__PURE__ */ __name(async (item, params, viewer, info) => {
-        const instance = getInstance2(target.service);
-        return await instance[propertyKey](item, params, viewer, info);
-      }, "resolve")
+import {
+  modelResolver
+} from "@orion-js/resolvers";
+var serviceMetadata2 = /* @__PURE__ */ new WeakMap();
+var modelResolversMetadata = /* @__PURE__ */ new WeakMap();
+function ModelResolvers(typedSchema, options = {}) {
+  return (target, context) => {
+    Service2()(target, context);
+    const modelName = options.modelName || typedSchema.name;
+    context.addInitializer(function() {
+      serviceMetadata2.set(this, {
+        _serviceType: "modelResolvers",
+        options,
+        _typedSchema: typedSchema,
+        _modelName: modelName
+      });
     });
   };
 }
-__name(ModelResolver, "ModelResolver");
-function ModelResolvers(typedSchema, options = {}) {
-  return (target) => {
-    Service2()(target);
-    target.prototype.modelName = options.modelName || typedSchema.name;
-    if (!target.prototype.modelName) {
-      throw new Error("The specified model has no name or is not a model");
-    }
-    target.prototype.typedSchema = typedSchema;
-    target.prototype.service = target;
-    target.getModel = () => getModelForClass(target);
+function ModelResolver(options) {
+  return (method, context) => {
+    const propertyKey = String(context.name);
+    context.addInitializer(function() {
+      const modelResolvers = modelResolversMetadata.get(this) || {};
+      modelResolvers[propertyKey] = modelResolver({
+        params: getTargetMetadata(method, propertyKey, "params") || {},
+        returns: getTargetMetadata(method, propertyKey, "returns") || "string",
+        middlewares: getTargetMetadata(method, propertyKey, "middlewares") || [],
+        ...options,
+        resolve: this[propertyKey].bind(this)
+      });
+      modelResolversMetadata.set(this, modelResolvers);
+    });
+    return method;
   };
 }
-__name(ModelResolvers, "ModelResolvers");
 function getServiceModelResolvers(target) {
-  if (!target.prototype) {
-    throw new UserError3("You must pass a class to getResolvers");
+  const instance = getInstance2(target);
+  if (!serviceMetadata2.has(instance.constructor)) {
+    throw new Error(
+      "You must pass a class decorated with @ModelResolvers to getServiceModelResolvers"
+    );
+  }
+  const instanceMetadata = serviceMetadata2.get(instance.constructor);
+  if (instanceMetadata._serviceType !== "modelResolvers") {
+    throw new Error(
+      "You must pass a class decorated with @ModelResolvers to getServiceModelResolvers"
+    );
   }
+  const modelResolversMap = modelResolversMetadata.get(instance) || {};
   return {
-    [target.prototype.modelName]: target.prototype.resolvers || {}
+    [instanceMetadata._modelName]: modelResolversMap
   };
 }
-__name(getServiceModelResolvers, "getServiceModelResolvers");
 
 // src/service/subscription.ts
-import { Container, Service as Service3 } from "@orion-js/services";
-import { UserError as UserError4 } from "@orion-js/helpers";
+import { getInstance as getInstance3, Service as Service3 } from "@orion-js/services";
+var serviceMetadata3 = /* @__PURE__ */ new WeakMap();
+var subscriptionsMetadata = /* @__PURE__ */ new WeakMap();
 function Subscriptions() {
-  return (target) => {
-    Service3()(target);
-    target.prototype.service = target;
-    target.prototype.serviceType = "subscriptions";
+  return (target, context) => {
+    Service3()(target, context);
+    context.addInitializer(function() {
+      serviceMetadata3.set(this, { _serviceType: "subscriptions" });
+    });
   };
 }
-__name(Subscriptions, "Subscriptions");
 function Subscription(options) {
-  return (object, propertyName, index) => {
-    const sub = subscription_default({
-      name: propertyName,
-      ...options
-    });
-    object.subscriptions = object.subscriptions || {};
-    object.subscriptions[propertyName] = sub;
-    Container.registerHandler({
-      object,
-      propertyName,
-      index,
-      value: /* @__PURE__ */ __name((_containerInstance) => {
-        if (!object.serviceType || object.serviceType !== "subscriptions") {
-          throw new Error("You must pass a class decorated with @Subscriptions if you want to use @Subscription");
-        }
-        return sub;
-      }, "value")
+  return (_target, context) => {
+    const propertyKey = String(context.name);
+    context.addInitializer(function() {
+      const repo = serviceMetadata3.get(this.constructor);
+      if (!repo || repo._serviceType !== "subscriptions") {
+        throw new Error(
+          "You must pass a class decorated with @Subscriptions if you want to use @Subscription"
+        );
+      }
+      const subscriptions = subscriptionsMetadata.get(this) || {};
+      subscriptions[propertyKey] = subscription_default({
+        name: propertyKey,
+        ...options
+      });
+      subscriptionsMetadata.set(this, subscriptions);
+      this[propertyKey] = subscriptions[propertyKey];
     });
   };
 }
-__name(Subscription, "Subscription");
 function getServiceSubscriptions(target) {
-  if (!target.prototype) {
-    throw new UserError4("You must pass a class to getSubscriptions");
+  const instance = getInstance3(target);
+  if (!serviceMetadata3.has(instance.constructor)) {
+    throw new Error(
+      "You must pass a class decorated with @Subscriptions to getServiceSubscriptions"
+    );
+  }
+  const instanceMetadata = serviceMetadata3.get(instance.constructor);
+  if (instanceMetadata._serviceType !== "subscriptions") {
+    throw new Error(
+      "You must pass a class decorated with @Subscriptions to getServiceSubscriptions"
+    );
   }
-  return target.prototype.subscriptions || {};
+  const subscriptionsMap = subscriptionsMetadata.get(instance) || {};
+  return subscriptionsMap;
 }
-__name(getServiceSubscriptions, "getServiceSubscriptions");
 export {
   GraphQL2 as GraphQL,
   ModelResolver,