@orion-js/graphql 4.0.0-next.9 → 4.0.1

package/dist/index.cjs

@@ -42,12 +42,17 @@ __export(index_exports, {
   Subscription: () => Subscription,
   Subscriptions: () => Subscriptions,
   UseMiddleware: () => UseMiddleware,
+  createModelResolver: () => createModelResolver,
+  createMutation: () => createMutation,
+  createQuery: () => createQuery,
+  createResolver: () => import_resolvers2.createResolver,
   getBasicResultQuery: () => getBasicQuery,
   getServiceModelResolvers: () => getServiceModelResolvers,
   getServiceResolvers: () => getServiceResolvers,
   getServiceSubscriptions: () => getServiceSubscriptions,
   getTargetMetadata: () => getTargetMetadata,
   getWebsockerViewer: () => getWebsockerViewer,
+  internalResolversMetadata: () => internalResolversMetadata,
   resolversSchemas: () => resolversSchemas_default,
   serializeSchema: () => serializeSchema,
   setGetWebsockerViewer: () => setGetWebsockerViewer,
@@ -57,6 +62,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/subscription/index.ts
+var import_schema = require("@orion-js/schema");
+
 // src/pubsub.ts
 var pubsub = null;
 var setPubsub = function(newPubsub) {
@@ -75,28 +83,36 @@ function getChannelName_default(name, params) {
 }
 
 // src/subscription/index.ts
-var import_resolvers = require("@orion-js/resolvers");
-var createSubscription = function(options) {
-  const subscription = {
-    name: options.name
+var createSubscription = (options) => {
+  const subscription = {};
+  const getSubscriptionName = () => {
+    if (!subscription.name) {
+      throw new Error("This subscription is not yet initialized in GraphQL");
+    }
+    return subscription.name;
   };
   subscription.publish = async (params, data) => {
     const pubsub2 = getPubsub();
-    const channelName = getChannelName_default(subscription.name, params);
-    await pubsub2.publish(channelName, { [subscription.name]: data });
+    const channelName = getChannelName_default(getSubscriptionName(), params);
+    await pubsub2.publish(channelName, { [getSubscriptionName()]: data });
   };
   subscription.subscribe = async (params, viewer) => {
     const pubsub2 = getPubsub();
     try {
-      await (0, import_resolvers.checkPermissions)({ params, viewer, options: null }, options);
-      const channelName = getChannelName_default(subscription.name, params);
+      if (options.canSubscribe) {
+        const canSubscribe = await options.canSubscribe(params, viewer);
+        if (!canSubscribe) {
+          return pubsub2.asyncIterator("unauthorized");
+        }
+      }
+      const channelName = getChannelName_default(getSubscriptionName(), params);
       return pubsub2.asyncIterator(channelName);
-    } catch (error) {
+    } catch (_error) {
       return pubsub2.asyncIterator("unauthorized");
     }
   };
-  subscription.params = (0, import_resolvers.cleanParams)(options.params);
-  subscription.returns = (0, import_resolvers.cleanReturns)(options.returns);
+  subscription.params = (0, import_schema.getSchemaFromAnyOrionForm)(options.params) ?? {};
+  subscription.returns = (0, import_schema.getSchemaFromAnyOrionForm)(options.returns);
   return subscription;
 };
 var subscription_default = createSubscription;
@@ -310,7 +326,7 @@ var import_graphql7 = require("graphql");
 
 // src/buildSchema/getType/index.ts
 var import_graphql6 = require("graphql");
-var import_schema2 = require("@orion-js/schema");
+var import_schema3 = require("@orion-js/schema");
 
 // ../../node_modules/.pnpm/rambdax@11.3.1/node_modules/rambdax/src/type.js
 function type(input) {
@@ -597,6 +613,9 @@ function getScalar_default(fieldType) {
   if (fieldMap[fieldType.name]) {
     return fieldMap[fieldType.name];
   }
+  if (fieldType.name.startsWith("typedId:")) {
+    return fieldMap.string;
+  }
   if (fieldType.toGraphQLType) {
     const result = fieldType.toGraphQLType(GraphQL);
     if (result.then) {
@@ -609,7 +628,7 @@ function getScalar_default(fieldType) {
 
 // src/buildSchema/getArgs/getField.ts
 var import_graphql4 = require("graphql");
-var import_schema = require("@orion-js/schema");
+var import_schema2 = require("@orion-js/schema");
 
 // src/resolversSchemas/getStaticFields.ts
 function getStaticFields(schema) {
@@ -666,7 +685,7 @@ var resolveType = (type2) => {
   if (!type2.__isFieldType && (isType("Object", type2) || type2.__isModel)) {
     return resolvePlainObjectOrModelType(type2);
   }
-  const schemaType = (0, import_schema.getFieldType)(type2);
+  const schemaType = (0, import_schema2.getFieldType)(type2);
   return getScalar_default(schemaType);
 };
 var getField_default = resolveType;
@@ -676,7 +695,7 @@ async function getArgs_default(params) {
   if (!params) return;
   if (Object.keys(params).length === 0) return;
   const fields = {};
-  for (const key of Object.keys(params)) {
+  for (const key of Object.keys(params).filter((key2) => !key2.startsWith("__"))) {
     try {
       const type2 = getField_default(params[key].type);
       fields[key] = { type: type2 };
@@ -720,18 +739,18 @@ function errorHandler(error, data) {
 }
 
 // src/buildSchema/getType/getTypeAsResolver.ts
-function getTypeAsResolver_default({ resolver: resolver2, getGraphQLType: getGraphQLType2, options, schema }) {
-  const type2 = getGraphQLType2(resolver2.returns, options);
-  const args = getArgs_default(resolver2.params);
+function getTypeAsResolver_default({ resolver, getGraphQLType: getGraphQLType2, options, schema }) {
+  const type2 = getGraphQLType2(resolver.returns, options);
+  const args = getArgs_default(resolver.params);
   return {
     type: type2,
     args,
     async resolve(item, params, context, info) {
       try {
-        const result = await resolver2.resolve(item, params, context, info);
+        const result = await resolver.resolve(item, params, context, info);
         return result;
       } catch (error) {
-        errorHandler(error, { context, resolver: resolver2, options, schema });
+        errorHandler(error, { context, resolver, options, schema });
         throw error;
       }
     }
@@ -754,12 +773,12 @@ function getDynamicFields(schema) {
   if (!resolvers) return [];
   const keys = Object.keys(resolvers);
   return keys.map((key) => {
-    const resolver2 = resolvers[key];
+    const resolver = resolvers[key];
     return {
-      ...resolver2,
+      ...resolver,
       key
     };
-  }).filter((resolver2) => !resolver2.private);
+  }).filter((resolver) => !resolver.private);
 }
 
 // src/resolversSchemas/getModelLoadedResolvers.ts
@@ -769,12 +788,12 @@ function getModelLoadedResolvers(schema, options) {
   if (!resolvers) return [];
   const keys = Object.keys(resolvers);
   return keys.map((key) => {
-    const resolver2 = resolvers[key];
+    const resolver = resolvers[key];
     return {
-      ...resolver2,
+      ...resolver,
       key
     };
-  }).filter((resolver2) => !resolver2.private);
+  }).filter((resolver) => !resolver.private);
 }
 
 // src/buildSchema/getType/index.ts
@@ -794,23 +813,23 @@ var buildFields = (schema, options) => {
     }
   };
   const addDynamicFields = () => {
-    for (const resolver2 of getDynamicFields(schema)) {
+    for (const resolver of getDynamicFields(schema)) {
       try {
-        fields[resolver2.key] = getTypeAsResolver_default({ resolver: resolver2, getGraphQLType, options, schema });
+        fields[resolver.key] = getTypeAsResolver_default({ resolver, getGraphQLType, options, schema });
       } catch (error) {
         throw new Error(
-          `Error getting resolver type for resolver "${resolver2.key}": ${error.message}`
+          `Error getting resolver type for resolver "${resolver.key}": ${error.message}`
         );
       }
     }
   };
   const addModelLoadedResolvers = () => {
-    for (const resolver2 of getModelLoadedResolvers(schema, options)) {
+    for (const resolver of getModelLoadedResolvers(schema, options)) {
       try {
-        fields[resolver2.key] = getTypeAsResolver_default({ resolver: resolver2, getGraphQLType, options, schema });
+        fields[resolver.key] = getTypeAsResolver_default({ resolver, getGraphQLType, options, schema });
       } catch (error) {
         throw new Error(
-          `Error getting resolver type for resolver "${resolver2.key}": ${error.message}`
+          `Error getting resolver type for resolver "${resolver.key}": ${error.message}`
         );
       }
     }
@@ -826,8 +845,8 @@ function getGraphQLType(type2, options) {
   if (Array.isArray(type2)) {
     return new import_graphql6.GraphQLList(getGraphQLType(type2[0], options));
   }
-  if ((0, import_schema2.isSchemaLike)(type2)) {
-    const schema = (0, import_schema2.getSchemaWithMetadataFromAnyOrionForm)(type2);
+  if ((0, import_schema3.isSchemaLike)(type2)) {
+    const schema = (0, import_schema3.getSchemaWithMetadataFromAnyOrionForm)(type2);
     const modelName = schema.__modelName;
     if (schema.__graphQLType) {
       return schema.__graphQLType;
@@ -848,7 +867,7 @@ function getGraphQLType(type2, options) {
     registeredGraphQLTypes.set(modelName, { schema, graphQLType });
     return graphQLType;
   }
-  return getScalar_default((0, import_schema2.getFieldType)(type2));
+  return getScalar_default((0, import_schema3.getFieldType)(type2));
 }
 
 // src/buildSchema/getResolvers/resolversStore.ts
@@ -862,21 +881,21 @@ async function getResolvers_default(options, mutation) {
       name: key,
       resolver: resolvers[key]
     };
-  }).filter(({ resolver: resolver2 }) => !!resolver2.mutation === !!mutation).filter(({ resolver: resolver2 }) => !resolver2.private);
+  }).filter(({ resolver }) => !!resolver.mutation === !!mutation).filter(({ resolver }) => !resolver.private);
   const fields = {};
-  for (const { resolver: resolver2, name } of filteredResolvers) {
-    resolversStore[name] = resolver2;
-    const type2 = await getGraphQLType(resolver2.returns, options);
-    const args = await getArgs_default(resolver2.params);
+  for (const { resolver, name } of filteredResolvers) {
+    resolversStore[name] = resolver;
+    const type2 = await getGraphQLType(resolver.returns, options);
+    const args = await getArgs_default(resolver.params);
     fields[name] = {
       type: type2,
       args,
       async resolve(_root, params, context, info) {
         try {
-          const result = await resolver2.resolve(params, context, info);
+          const result = await resolver.resolve(params, context, info);
           return result;
         } catch (error) {
-          errorHandler(error, { context, resolver: resolver2, options, name });
+          errorHandler(error, { context, resolver, options, name });
           throw error;
         }
       }
@@ -1079,12 +1098,12 @@ async function startGraphQL_default(options) {
 }
 
 // src/resolversSchemas/params.ts
-var import_resolvers2 = require("@orion-js/resolvers");
+var import_resolvers = require("@orion-js/resolvers");
 var import_helpers2 = require("@orion-js/helpers");
 
 // src/resolversSchemas/ResolverParamsInfo.ts
-var import_schema3 = require("@orion-js/schema");
-var ResolverParamsInfo_default = (0, import_schema3.schemaWithName)("ResolverParams", {
+var import_schema4 = require("@orion-js/schema");
+var ResolverParamsInfo_default = (0, import_schema4.schemaWithName)("ResolverParams", {
   name: {
     type: "string"
   },
@@ -1100,13 +1119,12 @@ var ResolverParamsInfo_default = (0, import_schema3.schemaWithName)("ResolverPar
 });
 
 // src/resolversSchemas/serializeSchema.ts
-var import_schema5 = require("@orion-js/schema");
+var import_schema6 = require("@orion-js/schema");
 
 // src/resolversSchemas/getField.ts
-var import_schema4 = require("@orion-js/schema");
+var import_schema5 = require("@orion-js/schema");
 async function getParams(field) {
   const { type: type2 } = field;
-  console.log(type2, "getting parms");
   if (Array.isArray(type2)) {
     const serialized = await getParams({ ...field, type: type2[0] });
     return {
@@ -1115,9 +1133,9 @@ async function getParams(field) {
       __graphQLType: `[${serialized.__graphQLType}]`
     };
   }
-  const isSchema = (0, import_schema4.isSchemaLike)(type2);
+  const isSchema = (0, import_schema5.isSchemaLike)(type2);
   if (isSchema) {
-    const schemaOfType = (0, import_schema4.getSchemaWithMetadataFromAnyOrionForm)(type2);
+    const schemaOfType = (0, import_schema5.getSchemaWithMetadataFromAnyOrionForm)(type2);
     const modelName = schemaOfType.__modelName;
     if (!modelName) {
       throw new Error("The schema needs a model name to be serialized for GraphQL");
@@ -1132,7 +1150,7 @@ async function getParams(field) {
       __graphQLType: `${modelName}Input`
     };
   }
-  const schemaType = (0, import_schema4.getFieldType)(type2);
+  const schemaType = (0, import_schema5.getFieldType)(type2);
   const graphQLType = await getScalar_default(schemaType);
   const withoutKey = isType("Object", field) ? omit(["key"], field) : {};
   return {
@@ -1145,7 +1163,7 @@ async function getParams(field) {
 // src/resolversSchemas/serializeSchema.ts
 async function serializeSchema(params) {
   if (!params) return;
-  const schema = (0, import_schema5.getSchemaFromAnyOrionForm)(params);
+  const schema = (0, import_schema6.getSchemaFromAnyOrionForm)(params);
   if (Object.keys(schema).length === 0) return;
   const fields = {};
   console.log(schema, "schema");
@@ -1159,10 +1177,10 @@ async function serializeSchema(params) {
 }
 
 // src/resolversSchemas/params.ts
-var import_schema7 = require("@orion-js/schema");
+var import_schema8 = require("@orion-js/schema");
 
 // src/resolversSchemas/getBasicResultQuery.ts
-var import_schema6 = require("@orion-js/schema");
+var import_schema7 = require("@orion-js/schema");
 async function getBasicQuery(field) {
   if (!field.type) return "";
   if (Array.isArray(field.type)) {
@@ -1171,10 +1189,10 @@ async function getBasicQuery(field) {
       type: field.type[0]
     });
   }
-  if (!(0, import_schema6.isSchemaLike)(field.type)) {
+  if (!(0, import_schema7.isSchemaLike)(field.type)) {
     return field.key;
   }
-  const schema = (0, import_schema6.getSchemaFromAnyOrionForm)(field.type);
+  const schema = (0, import_schema7.getSchemaFromAnyOrionForm)(field.type);
   const fields = [];
   for (const field2 of getStaticFields(schema)) {
     fields.push(await getBasicQuery(field2));
@@ -1186,21 +1204,21 @@ async function getBasicQuery(field) {
 // src/resolversSchemas/params.ts
 function getResultTypeName(type2) {
   const returns = Array.isArray(type2) ? type2[0] : type2;
-  const schema = (0, import_schema7.getSchemaFromAnyOrionForm)(returns);
+  const schema = (0, import_schema8.getSchemaFromAnyOrionForm)(returns);
   if (schema == null ? void 0 : schema.__modelName) return schema.__modelName;
   return;
 }
 async function getInternalBasicResultQuery(type2) {
   const returns = Array.isArray(type2) ? type2[0] : type2;
-  if ((0, import_schema7.isSchemaLike)(returns)) {
-    const schema = (0, import_schema7.getSchemaFromAnyOrionForm)(returns);
+  if ((0, import_schema8.isSchemaLike)(returns)) {
+    const schema = (0, import_schema8.getSchemaFromAnyOrionForm)(returns);
     return await getBasicQuery({
       type: schema
     });
   }
   return "";
 }
-var params_default = (0, import_resolvers2.createResolver)({
+var params_default = (0, import_resolvers.createResolver)({
   params: {
     name: {
       type: "ID"
@@ -1212,21 +1230,21 @@ var params_default = (0, import_resolvers2.createResolver)({
   returns: ResolverParamsInfo_default,
   mutation: false,
   async resolve({ mutation, name }) {
-    const resolver2 = resolversStore[name];
-    if (!resolver2) {
+    const resolver = resolversStore[name];
+    if (!resolver) {
       throw new import_helpers2.UserError(
         "notFound",
         `${mutation ? "Mutation" : "Query"} named "${name}" not found`
       );
     }
-    if (!!resolver2.mutation !== !!mutation) {
+    if (!!resolver.mutation !== !!mutation) {
       throw new import_helpers2.UserError("incorrectType", `"${name}" is ${mutation ? "not" : ""} a mutation`);
     }
     return {
       name,
-      basicResultQuery: await getInternalBasicResultQuery(resolver2.returns),
-      params: await serializeSchema(resolver2.params),
-      result: getResultTypeName(resolver2.returns)
+      basicResultQuery: await getInternalBasicResultQuery(resolver.returns),
+      params: await serializeSchema(resolver.params),
+      result: getResultTypeName(resolver.returns)
     };
   }
 });
@@ -1250,7 +1268,7 @@ var OrionSubscription = class {
 
 // src/service/global.ts
 var import_services = require("@orion-js/services");
-var import_resolvers3 = require("@orion-js/resolvers");
+var import_resolvers2 = require("@orion-js/resolvers");
 
 // src/service/middlewares.ts
 var resolversMetadata = /* @__PURE__ */ new WeakMap();
@@ -1293,97 +1311,132 @@ function ResolverReturns(returns) {
 }
 
 // src/service/global.ts
+var createQuery = import_resolvers2.createResolver;
+var createMutation = (options) => {
+  return (0, import_resolvers2.createResolver)({
+    ...options,
+    mutation: true
+  });
+};
 var serviceMetadata = /* @__PURE__ */ new WeakMap();
-var resolversMetadata2 = /* @__PURE__ */ new WeakMap();
+var internalResolversMetadata = /* @__PURE__ */ new WeakMap();
 function Resolvers() {
   return (target, context) => {
     (0, import_services.Service)()(target, context);
-    context.addInitializer(function() {
-      serviceMetadata.set(this, { _serviceType: "resolvers" });
-    });
+    serviceMetadata.set(target, { _serviceType: "resolvers" });
   };
 }
 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);
+      const resolvers = internalResolversMetadata.get(this) || {};
+      if (context.kind === "method") {
+        resolvers[propertyKey] = (0, import_resolvers2.createResolver)({
+          resolverId: propertyKey,
+          params: getTargetMetadata(method, propertyKey, "params") || {},
+          returns: getTargetMetadata(method, propertyKey, "returns") || "string",
+          middlewares: getTargetMetadata(method, propertyKey, "middlewares") || [],
+          ...options,
+          resolve: this[propertyKey].bind(this)
+        });
+      }
+      if (context.kind === "field") {
+        resolvers[propertyKey] = this[propertyKey];
+      }
+      internalResolversMetadata.set(this, resolvers);
     });
     return method;
   };
 }
-function Mutation(options) {
+function Mutation(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,
-        mutation: true,
-        resolve: this[propertyKey].bind(this)
-      });
-      resolversMetadata2.set(this, resolvers);
+      const resolvers = internalResolversMetadata.get(this) || {};
+      if (context.kind === "method") {
+        resolvers[propertyKey] = (0, import_resolvers2.createResolver)({
+          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)
+        });
+      }
+      if (context.kind === "field") {
+        this[propertyKey].mutation = true;
+        resolvers[propertyKey] = this[propertyKey];
+      }
+      internalResolversMetadata.set(this, resolvers);
     });
     return method;
   };
 }
 function getServiceResolvers(target) {
   const instance = (0, import_services.getInstance)(target);
+  const className = instance.constructor.name;
+  const errorMessage = `You must pass a class decorated with @Resolvers to getServiceResolvers. Check the class ${className}`;
   if (!serviceMetadata.has(instance.constructor)) {
-    throw new Error("You must pass a class decorated with @Resolvers to getServiceResolvers");
+    throw new Error(errorMessage);
   }
   const instanceMetadata = serviceMetadata.get(instance.constructor);
   if (instanceMetadata._serviceType !== "resolvers") {
-    throw new Error("You must pass a class decorated with @Resolvers to getServiceResolvers");
+    throw new Error(`${errorMessage}. Got class type ${instanceMetadata._serviceType}`);
   }
-  const resolversMap = resolversMetadata2.get(instance) || {};
+  const resolversMap = internalResolversMetadata.get(instance) || {};
   return resolversMap;
 }
 
 // src/service/model.ts
 var import_services2 = require("@orion-js/services");
-var import_resolvers4 = require("@orion-js/resolvers");
+var import_resolvers3 = require("@orion-js/resolvers");
+var createModelResolver = import_resolvers3.createModelResolver;
 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;
+    const className = context.name;
+    const modelName = (() => {
+      if (options.modelName) {
+        return options.modelName;
+      }
+      if (typeof typedSchema.name === "string") {
+        return typedSchema.name;
+      }
+      if (typedSchema.__modelName) {
+        return typedSchema.__modelName;
+      }
+      throw new Error(`You must specify a model name for the model resolvers (at: ${className})`);
+    })();
     context.addInitializer(function() {
       serviceMetadata2.set(this, {
         _serviceType: "modelResolvers",
         options,
-        _typedSchema: typedSchema,
         _modelName: modelName
       });
     });
   };
 }
-function ModelResolver(options) {
+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)
-      });
+      if (context.kind === "method") {
+        modelResolvers[propertyKey] = createModelResolver({
+          params: getTargetMetadata(method, propertyKey, "params") || {},
+          returns: getTargetMetadata(method, propertyKey, "returns") || "string",
+          middlewares: getTargetMetadata(method, propertyKey, "middlewares") || [],
+          ...options,
+          resolve: this[propertyKey].bind(this)
+        });
+      }
+      if (context.kind === "field") {
+        modelResolvers[propertyKey] = this[propertyKey];
+      }
       modelResolversMetadata.set(this, modelResolvers);
     });
     return method;
@@ -1420,8 +1473,8 @@ function Subscriptions() {
     });
   };
 }
-function Subscription(options) {
-  return (_target, context) => {
+function Subscription() {
+  return (_method, context) => {
     const propertyKey = String(context.name);
     context.addInitializer(function() {
       const repo = serviceMetadata3.get(this.constructor);
@@ -1431,10 +1484,7 @@ function Subscription(options) {
         );
       }
       const subscriptions = subscriptionsMetadata.get(this) || {};
-      subscriptions[propertyKey] = subscription_default({
-        name: propertyKey,
-        ...options
-      });
+      subscriptions[propertyKey] = this[propertyKey];
       subscriptionsMetadata.set(this, subscriptions);
       this[propertyKey] = subscriptions[propertyKey];
     });
@@ -1471,12 +1521,17 @@ function getServiceSubscriptions(target) {
   Subscription,
   Subscriptions,
   UseMiddleware,
+  createModelResolver,
+  createMutation,
+  createQuery,
+  createResolver,
   getBasicResultQuery,
   getServiceModelResolvers,
   getServiceResolvers,
   getServiceSubscriptions,
   getTargetMetadata,
   getWebsockerViewer,
+  internalResolversMetadata,
   resolversSchemas,
   serializeSchema,
   setGetWebsockerViewer,