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

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");
@@ -317,7 +309,6 @@ var import_graphql10 = require("graphql");
 var import_graphql7 = require("graphql");
 
 // src/buildSchema/getType/index.ts
-var import_isPlainObject2 = __toESM(require("lodash/isPlainObject"), 1);
 var import_isArray2 = __toESM(require("lodash/isArray"), 1);
 var import_graphql6 = require("graphql");
 var import_schema2 = require("@orion-js/schema");
@@ -326,7 +317,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 +330,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 +362,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 +389,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 +424,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);
@@ -444,9 +432,11 @@ var import_graphql4 = require("graphql");
 var import_schema = require("@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];
@@ -456,72 +446,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 import_graphql4.GraphQLInputObjectType({
+      name: `${model.name}Input`,
+      fields
+    });
   }
-  storedModelInput[model.name] = new import_graphql4.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 ((0, import_isArray.default)(type)) {
-    const graphQLType = getParams(type[0]);
-    return new import_graphql4.GraphQLList(graphQLType);
-  } else if (!type._isFieldType && ((0, import_isPlainObject.default)(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 = (0, import_schema.getFieldType)(type);
-    const graphQLType = getScalar_default(schemaType);
-    return graphQLType;
+  return fields;
+};
+var resolveArrayType = (type) => new import_graphql4.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 ((0, import_isArray.default)(type)) return resolveArrayType(type);
+  if (!type.__isFieldType && ((0, import_isPlainObject.default)(type) || type.__isModel)) {
+    return resolvePlainObjectOrModelType(type);
+  }
+  const schemaType = (0, import_schema.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
-var import_crypto = __toESM(require("crypto"), 1);
+var import_node_crypto = __toESM(require("crypto"), 1);
 var import_graphql5 = require("graphql");
 function errorHandler(error, data) {
-  const message = `Error in resolver "${data.name}" ${data.model ? `of model "${data.model.name}"` : ""}`;
-  const hash = import_crypto.default.createHash("sha1").update(error.message, "utf8").digest("hex").substring(0, 10);
+  const message = `Error in resolver "${data.name}" ${data.schema ? `of model "${data.schema.__modelName}"` : ""}`;
+  const hash = import_node_crypto.default.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 import_graphql5.GraphQLError(error.message, {
       originalError: error,
@@ -533,148 +526,151 @@ function errorHandler(error, data) {
         info: error.getInfo()
       }
     });
-  } else {
-    console.error(message, error);
-    throw new import_graphql5.GraphQLError(`${error.message} [${hash}]`, {
-      // originalError: error,
-      extensions: {
-        isOrionError: false,
-        isValidationError: false,
-        code: "INTERNAL_SERVER_ERROR",
-        hash
-      }
-    });
   }
+  console.error(message, error);
+  throw new import_graphql5.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
+var import_lodash = require("lodash");
+var createGraphQLObjectType = (modelName, schema, options) => new import_graphql6.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 ((0, import_isArray2.default)(type)) {
-    const graphQLType = getGraphQLType(type[0], options);
-    return new import_graphql6.GraphQLList(graphQLType);
-  } else if (typeof type === "function" && type.getModel && type.__schemaId) {
-    return getGraphQLType(type.getModel(), options);
-  } else if (!type._isFieldType && ((0, import_isPlainObject2.default)(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 import_graphql6.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 = (0, import_schema2.getFieldType)(type);
-    const graphQLType = getScalar_default(schemaType);
+    return new import_graphql6.GraphQLList(getGraphQLType(type[0], options));
+  }
+  if ((0, import_schema2.isSchemaLike)(type)) {
+    const schema = (0, import_schema2.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 ((0, import_lodash.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((0, import_schema2.getFieldType)(type));
 }
-__name(getGraphQLType, "getGraphQLType");
 
 // src/buildSchema/getResolvers/resolversStore.ts
 var resolversStore = {};
@@ -687,26 +683,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;
         }
       }
@@ -714,7 +705,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 +716,6 @@ async function getQuery_default(options) {
     fields
   });
 }
-__name(getQuery_default, "default");
 
 // src/buildSchema/getMutation.ts
 var import_graphql8 = require("graphql");
@@ -739,7 +728,6 @@ async function getMutation_default(options) {
     fields
   });
 }
-__name(getMutation_default, "default");
 
 // src/buildSchema/getSubscription.ts
 var import_graphql9 = require("graphql");
@@ -763,7 +751,6 @@ async function getSubscriptions_default(options) {
   }
   return fields;
 }
-__name(getSubscriptions_default, "default");
 
 // src/buildSchema/getSubscription.ts
 async function getSubscription_default(options) {
@@ -774,27 +761,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,13 +783,12 @@ function formatError_default(apolloError) {
   }
   return response;
 }
-__name(formatError_default, "default");
 
 // src/getApolloOptions/index.ts
-var import_lodash = require("lodash");
+var import_lodash2 = require("lodash");
 async function getApolloOptions_default(options) {
   const schema = await buildSchema_default(options);
-  const passedOptions = (0, import_lodash.omit)(options, [
+  const passedOptions = (0, import_lodash2.omit)(options, [
     "resolvers",
     "modelResolvers",
     "subscriptions",
@@ -825,7 +803,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 +811,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 +819,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 +838,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 +860,6 @@ function startWebsocket_default(apolloOptions, options, wsServer) {
     }
   ];
 }
-__name(startWebsocket_default, "default");
 
 // src/startGraphQL.ts
 var import_http3 = require("@orion-js/http");
@@ -895,167 +874,152 @@ 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");
+var import_resolvers2 = require("@orion-js/resolvers");
 var import_helpers2 = require("@orion-js/helpers");
 
-// src/resolversSchemas/getField.ts
-var import_isPlainObject3 = __toESM(require("lodash/isPlainObject"), 1);
-var import_isArray3 = __toESM(require("lodash/isArray"), 1);
+// src/resolversSchemas/ResolverParamsInfo.ts
 var import_schema3 = require("@orion-js/schema");
+var ResolverParamsInfo_default = (0, import_schema3.schemaWithName)("ResolverParams", {
+  name: {
+    type: "string"
+  },
+  params: {
+    type: "blackbox"
+  },
+  result: {
+    type: "string"
+  },
+  basicResultQuery: {
+    type: "string"
+  }
+});
+
+// src/resolversSchemas/serializeSchema.ts
+var import_schema5 = require("@orion-js/schema");
+
+// src/resolversSchemas/getField.ts
+var import_schema4 = require("@orion-js/schema");
 var import_omit = __toESM(require("lodash/omit"), 1);
-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 ((0, import_isArray3.default)(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 && ((0, import_isPlainObject3.default)(type) || type.__isModel)) {
-    const model = type.__isModel ? type : type.__model;
-    if (!model || !model.__isModel) throw new Error("Type is not a Model");
+  }
+  const isSchema = (0, import_schema4.isSchemaLike)(type);
+  if (isSchema) {
+    const schemaOfType = (0, import_schema4.getSchemaWithMetadataFromAnyOrionForm)(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 {
       ...(0, import_omit.default)(field, "key"),
       type: fields,
-      __graphQLType: model.name + "Input"
-    };
-  } else {
-    const schemaType = await (0, import_schema3.getFieldType)(type);
-    const graphQLType = await getScalar_default(schemaType);
-    return {
-      ...(0, import_omit.default)(field, "key"),
-      type: schemaType.name,
-      __graphQLType: graphQLType.name
+      __graphQLType: `${modelName}Input`
     };
   }
+  const schemaType = (0, import_schema4.getFieldType)(type);
+  const graphQLType = await getScalar_default(schemaType);
+  return {
+    ...(0, import_omit.default)(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 = (0, import_schema5.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
+var import_schema7 = require("@orion-js/schema");
 
 // src/resolversSchemas/getBasicResultQuery.ts
-var import_isArray4 = __toESM(require("lodash/isArray"), 1);
+var import_isArray3 = __toESM(require("lodash/isArray"), 1);
+var import_schema6 = require("@orion-js/schema");
 async function getBasicQuery(field) {
   if (!field.type) return "";
-  if ((0, import_isArray4.default)(field.type) && field.type[0].__model || field.type.__model) {
-    const model = (0, import_isArray4.default)(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 ((0, import_isArray3.default)(field.type)) {
+    return getBasicQuery({
+      ...field,
+      type: field.type[0]
+    });
+  }
+  if (!(0, import_schema6.isSchemaLike)(field.type)) {
     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) => {
-  return returns && returns.__isModel;
-}, "resolverReturnsIsModel");
-var ResolverParamsInfo_default = (0, import_models.createModel)({
-  name: "ResolverParams",
-  schema: {
-    name: {
-      type: String
-    }
-  },
-  resolvers: {
-    params: (0, import_resolvers2.resolver)({
-      returns: "blackbox",
-      resolve: /* @__PURE__ */ __name(async function({ resolver: resolver4 }) {
-        return await serializeSchema(resolver4.params);
-      }, "resolve")
-    }),
-    result: (0, import_resolvers2.resolver)({
-      returns: String,
-      resolve: /* @__PURE__ */ __name(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 }) {
-        const returns = (0, import_lodash2.isArray)(resolver4.returns) ? resolver4.returns[0] : resolver4.returns;
-        return await getBasicQuery({
-          type: resolverReturnsIsModel(returns) ? returns.getSchema() : ""
-        });
-      }, "resolve")
-    })
+  const schema = (0, import_schema6.getSchemaFromAnyOrionForm)(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 = (0, import_resolvers3.resolver)({
+function getResultTypeName(type) {
+  const returns = Array.isArray(type) ? type[0] : type;
+  const schema = (0, import_schema7.getSchemaFromAnyOrionForm)(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 ((0, import_schema7.isSchemaLike)(returns)) {
+    const schema = (0, import_schema7.getSchemaFromAnyOrionForm)(returns);
+    return await getBasicQuery({
+      type: schema
+    });
+  }
+  return "";
+}
+var params_default = (0, import_resolvers2.createResolver)({
   params: {
     name: {
       type: "ID"
@@ -1066,19 +1030,24 @@ var params_default = (0, import_resolvers3.resolver)({
   },
   returns: ResolverParamsInfo_default,
   mutation: false,
-  resolve: /* @__PURE__ */ __name(async function({ mutation, name }, viewer) {
-    const resolver4 = resolversStore[name];
-    if (!resolver4) {
-      throw new import_helpers2.UserError("notFound", `${mutation ? "Mutation" : "Query"} named "${name}" not found`);
+  async resolve({ mutation, name }) {
+    const resolver2 = resolversStore[name];
+    if (!resolver2) {
+      throw new import_helpers2.UserError(
+        "notFound",
+        `${mutation ? "Mutation" : "Query"} named "${name}" not found`
+      );
     }
-    if (!!resolver4.mutation !== !!mutation) {
+    if (!!resolver2.mutation !== !!mutation) {
       throw new import_helpers2.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
@@ -1090,183 +1059,222 @@ 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");
-var import_resolvers4 = require("@orion-js/resolvers");
-var import_helpers3 = require("@orion-js/helpers");
+var import_resolvers3 = require("@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) => {
-    (0, import_services.Service)()(target);
-    target.prototype.service = target;
+  return (target, context) => {
+    (0, import_services.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] = (0, import_resolvers4.resolver)({
-      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 = (0, import_services.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] = (0, import_resolvers3.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] = (0, import_resolvers4.resolver)({
-      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 = (0, import_services.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] = (0, import_resolvers3.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 import_helpers3.UserError("You must pass a class to getResolvers");
+  const instance = (0, import_services.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
 var import_services2 = require("@orion-js/services");
-var import_resolvers5 = require("@orion-js/resolvers");
-var import_helpers4 = require("@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] = (0, import_resolvers5.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 = (0, import_services2.getInstance)(target.service);
-        return await instance[propertyKey](item, params, viewer, info);
-      }, "resolve")
+var import_resolvers4 = require("@orion-js/resolvers");
+var serviceMetadata2 = /* @__PURE__ */ new WeakMap();
+var modelResolversMetadata = /* @__PURE__ */ new WeakMap();
+function ModelResolvers(typedSchema, options = {}) {
+  return (target, context) => {
+    (0, import_services2.Service)()(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) => {
-    (0, import_services2.Service)()(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] = (0, import_resolvers4.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 import_helpers4.UserError("You must pass a class to getResolvers");
+  const instance = (0, import_services2.getInstance)(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
 var import_services3 = require("@orion-js/services");
-var import_helpers5 = require("@orion-js/helpers");
+var serviceMetadata3 = /* @__PURE__ */ new WeakMap();
+var subscriptionsMetadata = /* @__PURE__ */ new WeakMap();
 function Subscriptions() {
-  return (target) => {
-    (0, import_services3.Service)()(target);
-    target.prototype.service = target;
-    target.prototype.serviceType = "subscriptions";
+  return (target, context) => {
+    (0, import_services3.Service)()(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;
-    import_services3.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 import_helpers5.UserError("You must pass a class to getSubscriptions");
+  const instance = (0, import_services3.getInstance)(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");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   GraphQL,