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

package/dist/index.js

@@ -254,10 +254,13 @@ 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";
@@ -378,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];
@@ -392,49 +397,57 @@ function getStaticFields(model) {
 }
 
 // src/buildSchema/getArgs/getField.ts
+Symbol.metadata ?? (Symbol.metadata = Symbol("Symbol.metadata"));
 var storedModelInput = {};
-var getModelInput = 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];
 };
-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");
   }
-}
+  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);
+      const type = getField_default(params[key].type);
       fields[key] = { type };
     } catch (error) {
       throw new Error(`Error creating GraphQL resolver params argument ${key}: ${error.message}`);
@@ -447,10 +460,10 @@ function getArgs_default(params) {
 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,
@@ -462,33 +475,32 @@ 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
+    }
+  });
 }
 
 // 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;
       }
     }
@@ -496,97 +508,117 @@ function getTypeAsResolver_default({ resolver: resolver4, getGraphQLType: getGra
 }
 
 // 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);
 }
 
 // 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);
 }
 
 // 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: () => {
-        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;
+    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;
       }
-    });
-    return model.graphQLType;
-  } else {
-    const schemaType = getFieldType2(type);
-    const graphQLType = getScalar_default(schemaType);
+      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));
 }
 
 // src/buildSchema/getResolvers/resolversStore.ts
@@ -600,21 +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;
         }
       }
@@ -808,6 +840,7 @@ async function startGraphQL_default(options) {
       path: "/graphql",
       bodyParser: "json",
       async resolve(req, res, viewer) {
+        ;
         req._viewer = viewer;
         return middleware(req, res, req.next);
       }
@@ -816,124 +849,130 @@ async function startGraphQL_default(options) {
 }
 
 // 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],
       __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
+  };
 }
 
 // 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;
 }
 
+// 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;
   }
-}
-
-// src/resolversSchemas/ResolverParamsInfo.ts
-import { createModel } from "@orion-js/models";
-import { resolver } from "@orion-js/resolvers";
-import { isArray as isArray5 } from "lodash";
-var resolverReturnsIsModel = (returns) => {
-  return returns && returns.__isModel;
-};
-var ResolverParamsInfo_default = createModel({
-  name: "ResolverParams",
-  schema: {
-    name: {
-      type: String
-    }
-  },
-  resolvers: {
-    params: resolver({
-      returns: "blackbox",
-      resolve: async function({ resolver: resolver4 }) {
-        return await serializeSchema(resolver4.params);
-      }
-    }),
-    result: resolver({
-      returns: String,
-      resolve: async function({ resolver: resolver4 }) {
-        const returns = isArray5(resolver4.returns) ? resolver4.returns[0] : resolver4.returns;
-        if (resolverReturnsIsModel(returns)) return returns.name;
-        return;
-      }
-    }),
-    basicResultQuery: resolver({
-      returns: String,
-      resolve: async function({ resolver: resolver4 }) {
-        const returns = isArray5(resolver4.returns) ? resolver4.returns[0] : resolver4.returns;
-        return await getBasicQuery({
-          type: resolverReturnsIsModel(returns) ? returns.getSchema() : ""
-        });
-      }
-    })
+  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"
@@ -944,18 +983,23 @@ var params_default = resolver2({
   },
   returns: ResolverParamsInfo_default,
   mutation: false,
-  resolve: async function({ mutation, name }, viewer) {
-    const resolver4 = resolversStore[name];
-    if (!resolver4) {
+  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 };
+    return {
+      name,
+      basicResultQuery: await getInternalBasicResultQuery(resolver2.returns),
+      params: await serializeSchema(resolver2.params),
+      result: getResultTypeName(resolver2.returns)
+    };
   }
 });
 
@@ -978,79 +1022,107 @@ var OrionSubscription = class {
 
 // 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);
 }
 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;
+  };
 }
-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" });
+    });
   };
 }
-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: async (params, viewer, info) => {
-        const instance = getInstance(target.service);
-        return await instance[propertyKey](params, viewer, info);
-      }
+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;
   };
 }
 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: async (params, viewer, info) => {
-        const instance = getInstance(target.service);
-        return await instance[propertyKey](params, viewer, info);
-      }
+  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;
   };
 }
 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;
 }
 
 // src/service/model.ts
@@ -1058,82 +1130,105 @@ import { getInstance as getInstance2, Service as Service2 } from "@orion-js/serv
 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: async (item, params, viewer, info) => {
-        const instance = getInstance2(target.service);
-        return await instance[propertyKey](item, params, viewer, info);
-      }
+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
+      });
     });
   };
 }
-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;
   };
 }
 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
   };
 }
 
 // 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" });
+    });
   };
 }
 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: (_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;
+  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];
     });
   };
 }
 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;
 }
 export {
   GraphQL2 as GraphQL,