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

package/dist/index.d.ts

@@ -1,27 +1,36 @@
 import * as _orion_js_resolvers from '@orion-js/resolvers';
-import { ResolverOptions, GlobalResolverResolve, ModelResolverResolve, Resolver, ModelResolver as ModelResolver$1, ResolverMiddleware } from '@orion-js/resolvers';
+import { ResolverOptions, GlobalResolverOptions, GlobalResolver, ModelResolver as ModelResolver$1, GlobalResolverResolve, ModelResolverResolve, ResolverMiddleware } from '@orion-js/resolvers';
+export { createResolver } from '@orion-js/resolvers';
+import * as _orion_js_schema from '@orion-js/schema';
+import { SchemaFieldType, InferSchemaType, Schema, SchemaWithMetadata, SchemaNode } from '@orion-js/schema';
 import { GlobalResolversMap, ModelResolversMap } from '@orion-js/models';
 import { express } from '@orion-js/http';
 import { PubSubEngine } from 'graphql-subscriptions';
 import { ApolloServerOptions } from '@apollo/server';
-import { Schema, SchemaWithMetadata, SchemaNode } from '@orion-js/schema';
 import * as graphql from 'graphql';
 export { graphql as GraphQL };
 
-declare class OrionSubscription<TParams = any, ReturnType = any> {
+declare class OrionSubscription<TParamsSchema extends SchemaFieldType = SchemaFieldType, TReturnsSchema extends SchemaFieldType = SchemaFieldType> {
     name: string;
-    params: object;
-    subscribe: (callParams: object, viewer: object) => {};
-    returns: ReturnType;
-    publish: (params: TParams, data: ReturnType) => Promise<void>;
+    params: TParamsSchema;
+    subscribe: (callParams: InferSchemaType<TParamsSchema>, viewer: InferSchemaType<TReturnsSchema>) => {};
+    returns: TReturnsSchema;
+    publish: (params: InferSchemaType<TParamsSchema>, data: InferSchemaType<TReturnsSchema>) => Promise<void>;
 }
-type CreateOrionSubscriptionFunction = <T = any, ReturnType = any>(options: OrionSubscriptionOptions) => OrionSubscription<T, ReturnType>;
+type CreateOrionSubscriptionFunction = <TParamsSchema extends SchemaFieldType = SchemaFieldType, TReturnsSchema extends SchemaFieldType = SchemaFieldType, TViewer = any>(options: OrionSubscriptionOptions<TParamsSchema, TReturnsSchema, TViewer>) => OrionSubscription<TParamsSchema, TReturnsSchema>;
 interface OrionSubscriptionsMap {
     [key: string]: OrionSubscription;
 }
-interface OrionSubscriptionOptions extends Omit<ResolverOptions, 'resolve'> {
-    name?: string;
-}
+type OrionSubscriptionOptions<TParamsSchema extends SchemaFieldType = SchemaFieldType, TReturnsSchema extends SchemaFieldType = SchemaFieldType, TViewer = any> = Omit<ResolverOptions<TParamsSchema, TReturnsSchema, TViewer>, 'resolve'> & {
+    /**
+     * This function is used to check if the user can subscribe to the subscription.
+     * If not provided, the subscription will be public.
+     * @param params - The parameters of the subscription.
+     * @param viewer - The viewer of the subscription.
+     * @returns true if the user can subscribe to the subscription, false otherwise.
+     */
+    canSubscribe?: (params: InferSchemaType<TParamsSchema>, viewer: TViewer) => Promise<boolean>;
+};
 
 declare const createSubscription: CreateOrionSubscriptionFunction;
 
@@ -66,7 +75,7 @@ declare function export_default$1(options: StartGraphQLOptions): Promise<void>;
 declare function export_default(apolloOptions: ApolloServerOptions<any>, options: StartGraphQLOptions): void;
 
 declare const _default$1: {
-    params: _orion_js_resolvers.Resolver<_orion_js_resolvers.GlobalResolverResolve<{
+    params: _orion_js_resolvers.GlobalResolver<{
         name: {
             type: "ID";
         };
@@ -86,7 +95,7 @@ declare const _default$1: {
         basicResultQuery: {
             type: "string";
         };
-    }, any, any>, undefined>;
+    }, any, any>;
 };
 
 declare const _default: {
@@ -108,43 +117,47 @@ declare function serializeSchema(params: Schema): Promise<SchemaWithMetadata>;
 
 declare function getBasicQuery(field: SchemaNode): Promise<string>;
 
-type InternalGlobalResolverResolveAtDecorator<This, TParams, TReturns, TViewer, TInfo> = (this: This, ...args: Parameters<GlobalResolverResolve<TParams, TReturns, TViewer, TInfo>>) => ReturnType<GlobalResolverResolve<TParams, TReturns, TViewer, TInfo>>;
-type InternalModelResolverResolveAtDecorator<This, TItem, TParams, TReturns, TViewer, TInfo> = (this: This, ...args: Parameters<ModelResolverResolve<TItem, TParams, TReturns, TViewer, TInfo>>) => ReturnType<ModelResolverResolve<TItem, TParams, TReturns, TViewer, TInfo>>;
-type InternalDynamicResolverResolveAtDecorator<This, TParams = any, TReturns = any, TViewer = any, TItem = any, TInfo = any> = TItem extends undefined ? InternalGlobalResolverResolveAtDecorator<This, TParams, TReturns, TViewer, TInfo> : InternalModelResolverResolveAtDecorator<This, TItem, TParams, TReturns, TViewer, TInfo>;
-
+declare const createQuery: <TParams extends SchemaFieldType = any, TReturns extends SchemaFieldType = any, TViewer = any, TInfo = any>(options: GlobalResolverOptions<TParams, TReturns, TViewer, TInfo>) => GlobalResolver<TParams, TReturns, TViewer, TInfo>;
+declare const createMutation: <TParams extends SchemaFieldType = any, TReturns extends SchemaFieldType = any, TViewer = any, TInfo = any>(options: Omit<GlobalResolverOptions<TParams, TReturns, TViewer, TInfo>, "mutation">) => GlobalResolver<TParams, TReturns, TViewer, TInfo>;
+declare const internalResolversMetadata: WeakMap<any, Record<string, any>>;
 declare function Resolvers(): (target: any, context: ClassDecoratorContext<any>) => void;
-declare function Query<This>(options?: Omit<ResolverOptions<any>, 'resolve' | 'mutation'>): (method: InternalGlobalResolverResolveAtDecorator<This, any, any, any, any>, context: ClassMethodDecoratorContext<This, typeof method>) => InternalGlobalResolverResolveAtDecorator<This, any, any, any, any>;
-declare function Mutation<This, TParams, TReturns, TViewer, TInfo>(options: Omit<ResolverOptions<any>, 'resolve' | 'mutation'>): (method: InternalGlobalResolverResolveAtDecorator<This, TParams, TReturns, TViewer, TInfo>, context: ClassMethodDecoratorContext<This, typeof method>) => InternalGlobalResolverResolveAtDecorator<This, TParams, TReturns, TViewer, TInfo>;
+declare function Query(): (method: any, context: ClassFieldDecoratorContext | ClassMethodDecoratorContext) => any;
+declare function Query(options?: Omit<ResolverOptions<any>, 'resolve' | 'mutation'>): (method: any, context: ClassMethodDecoratorContext) => any;
+declare function Mutation(): (method: any, context: ClassFieldDecoratorContext | ClassMethodDecoratorContext) => any;
+declare function Mutation(options?: Omit<ResolverOptions<any>, 'resolve' | 'mutation'>): (method: any, context: ClassMethodDecoratorContext) => any;
 declare function getServiceResolvers(target: any): {
-    [key: string]: Resolver<GlobalResolverResolve>;
+    [key: string]: GlobalResolver<any, any, any, any>;
 };
 
+declare const createModelResolver: <TItem = any, TParams extends _orion_js_schema.SchemaFieldType = any, TReturns extends _orion_js_schema.SchemaFieldType = any, TViewer = any, TInfo = any>(options: _orion_js_resolvers.ModelResolverOptions<TItem, TParams, TReturns, TViewer, TInfo>) => ModelResolver$1<TItem, TParams, TReturns, TViewer, TInfo>;
 interface ModelResolversOptions {
     modelName?: string;
 }
 declare function ModelResolvers(typedSchema: any, options?: ModelResolversOptions): (target: any, context: ClassDecoratorContext<any>) => void;
-declare function ModelResolver<This, TItem, TParams, TReturns, TViewer, TInfo>(options?: Omit<ResolverOptions<any>, 'resolve' | 'middlewares'>): (method: InternalModelResolverResolveAtDecorator<This, TItem, TParams, TReturns, TViewer, TInfo>, context: ClassMethodDecoratorContext<This, typeof method>) => InternalModelResolverResolveAtDecorator<This, TItem, TParams, TReturns, TViewer, TInfo>;
+declare function ModelResolver(): (method: any, context: ClassFieldDecoratorContext | ClassMethodDecoratorContext) => any;
+declare function ModelResolver(options?: Omit<ResolverOptions<any>, 'resolve' | 'middlewares'>): (method: any, context: ClassMethodDecoratorContext) => any;
 declare function getServiceModelResolvers(target: any): {
     [key: string]: {
-        [key: string]: ModelResolver$1<GlobalResolverResolve>;
+        [key: string]: ModelResolver$1;
     };
 };
 
 declare function Subscriptions(): (target: any, context: ClassDecoratorContext<any>) => void;
-declare function Subscription<TParams, TReturns>(options: Omit<OrionSubscriptionOptions, 'params' | 'returns'> & {
-    params: TParams;
-    returns: TReturns;
-}): (_target: any, context: ClassFieldDecoratorContext) => void;
+declare function Subscription(): (method: any, context: ClassFieldDecoratorContext) => any;
 declare function getServiceSubscriptions(target: any): {
     [key: string]: OrionSubscription;
 };
 
+type InternalGlobalResolverResolveAtDecorator<This, TParams, TReturns, TViewer, TInfo> = (this: This, ...args: Parameters<GlobalResolverResolve<TParams, TReturns, TViewer, TInfo>>) => ReturnType<GlobalResolverResolve<TParams, TReturns, TViewer, TInfo>>;
+type InternalModelResolverResolveAtDecorator<This, TItem, TParams extends SchemaFieldType, TReturns extends SchemaFieldType, TViewer, TInfo> = (this: This, ...args: Parameters<ModelResolverResolve<TItem, TParams, TReturns, TViewer, TInfo>>) => ReturnType<ModelResolverResolve<TItem, TParams, TReturns, TViewer, TInfo>>;
+type InternalDynamicResolverResolveAtDecorator<This, TParams extends SchemaFieldType = any, TReturns extends SchemaFieldType = any, TViewer = any, TItem = any, TInfo = any> = TItem extends undefined ? InternalGlobalResolverResolveAtDecorator<This, TParams, TReturns, TViewer, TInfo> : InternalModelResolverResolveAtDecorator<This, TItem, TParams, TReturns, TViewer, TInfo>;
+
 declare function getTargetMetadata(target: any, propertyKey: string, metadataKey: string): any;
 declare function UseMiddleware<TMiddleware extends ResolverMiddleware, This>(params: TMiddleware): (method: InternalDynamicResolverResolveAtDecorator<This, any, any, any, any, any>, context: ClassMethodDecoratorContext<This, typeof method>) => InternalGlobalResolverResolveAtDecorator<This, any, any, any, any> | InternalModelResolverResolveAtDecorator<This, any, any, any, any, any>;
-declare function ResolverParams<TParams, This>(params: TParams): (method: InternalDynamicResolverResolveAtDecorator<This, TParams>, context: ClassMethodDecoratorContext<This, typeof method>) => InternalGlobalResolverResolveAtDecorator<This, TParams, any, any, any> | InternalModelResolverResolveAtDecorator<This, any, TParams, any, any, any>;
-declare function ResolverReturns<This>(returns: any): (method: InternalDynamicResolverResolveAtDecorator<This, any, any>, context: ClassMethodDecoratorContext<This, typeof method>) => InternalGlobalResolverResolveAtDecorator<This, any, any, any, any> | InternalModelResolverResolveAtDecorator<This, any, any, any, any, any>;
+declare function ResolverParams<TParams extends SchemaFieldType, This>(params: TParams): (method: InternalDynamicResolverResolveAtDecorator<This, TParams, any, any, any, any>, context: ClassMethodDecoratorContext<This, typeof method>) => InternalGlobalResolverResolveAtDecorator<This, TParams, any, any, any> | InternalModelResolverResolveAtDecorator<This, any, TParams, any, any, any>;
+declare function ResolverReturns<This>(returns: any): (method: InternalDynamicResolverResolveAtDecorator<This, any, any, any, any, any>, context: ClassMethodDecoratorContext<This, typeof method>) => InternalGlobalResolverResolveAtDecorator<This, any, any, any, any> | InternalModelResolverResolveAtDecorator<This, any, any, any, any, any>;
 
 declare const getWebsockerViewer: (connectionParams: any) => Promise<any>;
 declare const setGetWebsockerViewer: (getViewerFunc: (connectionParams: any) => any) => void;
 
-export { type CreateOrionSubscriptionFunction, type ExecuteGraphQLCache, ModelResolver, ModelResolvers, type ModelResolversOptions, type ModelsResolversMap, Mutation, OrionSubscription, type OrionSubscriptionOptions, type OrionSubscriptionsMap, Query, ResolverParams, _default as ResolverParamsInfo, ResolverReturns, Resolvers, type StartGraphQLOptions, Subscription, Subscriptions, UseMiddleware, getBasicQuery as getBasicResultQuery, getServiceModelResolvers, getServiceResolvers, getServiceSubscriptions, getTargetMetadata, getWebsockerViewer, _default$1 as resolversSchemas, serializeSchema, setGetWebsockerViewer, export_default$1 as startGraphQL, export_default as startGraphiQL, createSubscription as subscription };
+export { type CreateOrionSubscriptionFunction, type ExecuteGraphQLCache, ModelResolver, ModelResolvers, type ModelResolversOptions, type ModelsResolversMap, Mutation, OrionSubscription, type OrionSubscriptionOptions, type OrionSubscriptionsMap, Query, ResolverParams, _default as ResolverParamsInfo, ResolverReturns, Resolvers, type StartGraphQLOptions, Subscription, Subscriptions, UseMiddleware, createModelResolver, createMutation, createQuery, getBasicQuery as getBasicResultQuery, getServiceModelResolvers, getServiceResolvers, getServiceSubscriptions, getTargetMetadata, getWebsockerViewer, internalResolversMetadata, _default$1 as resolversSchemas, serializeSchema, setGetWebsockerViewer, export_default$1 as startGraphQL, export_default as startGraphiQL, createSubscription as subscription };

package/dist/index.js

@@ -1,3 +1,6 @@
+// src/subscription/index.ts
+import { getSchemaFromAnyOrionForm } from "@orion-js/schema";
+
 // src/pubsub.ts
 var pubsub = null;
 var setPubsub = function(newPubsub) {
@@ -16,32 +19,36 @@ function getChannelName_default(name, params) {
 }
 
 // src/subscription/index.ts
-import {
-  checkPermissions as checkResolverPermissions,
-  cleanParams,
-  cleanReturns
-} from "@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 checkResolverPermissions({ 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 = cleanParams(options.params);
-  subscription.returns = cleanReturns(options.returns);
+  subscription.params = getSchemaFromAnyOrionForm(options.params) ?? {};
+  subscription.returns = getSchemaFromAnyOrionForm(options.returns);
   return subscription;
 };
 var subscription_default = createSubscription;
@@ -546,6 +553,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) {
@@ -625,7 +635,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 };
@@ -669,18 +679,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;
       }
     }
@@ -703,12 +713,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
@@ -718,12 +728,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
@@ -743,23 +753,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}`
         );
       }
     }
@@ -811,21 +821,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;
         }
       }
@@ -1049,7 +1059,7 @@ var ResolverParamsInfo_default = schemaWithName("ResolverParams", {
 });
 
 // src/resolversSchemas/serializeSchema.ts
-import { getSchemaFromAnyOrionForm } from "@orion-js/schema";
+import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm2 } from "@orion-js/schema";
 
 // src/resolversSchemas/getField.ts
 import {
@@ -1059,7 +1069,6 @@ import {
 } from "@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 {
@@ -1098,7 +1107,7 @@ async function getParams(field) {
 // src/resolversSchemas/serializeSchema.ts
 async function serializeSchema(params) {
   if (!params) return;
-  const schema = getSchemaFromAnyOrionForm(params);
+  const schema = getSchemaFromAnyOrionForm2(params);
   if (Object.keys(schema).length === 0) return;
   const fields = {};
   console.log(schema, "schema");
@@ -1112,10 +1121,10 @@ async function serializeSchema(params) {
 }
 
 // src/resolversSchemas/params.ts
-import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm3, isSchemaLike as isSchemaLike4 } from "@orion-js/schema";
+import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm4, isSchemaLike as isSchemaLike4 } from "@orion-js/schema";
 
 // src/resolversSchemas/getBasicResultQuery.ts
-import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm2, isSchemaLike as isSchemaLike3 } from "@orion-js/schema";
+import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm3, isSchemaLike as isSchemaLike3 } from "@orion-js/schema";
 async function getBasicQuery(field) {
   if (!field.type) return "";
   if (Array.isArray(field.type)) {
@@ -1127,7 +1136,7 @@ async function getBasicQuery(field) {
   if (!isSchemaLike3(field.type)) {
     return field.key;
   }
-  const schema = getSchemaFromAnyOrionForm2(field.type);
+  const schema = getSchemaFromAnyOrionForm3(field.type);
   const fields = [];
   for (const field2 of getStaticFields(schema)) {
     fields.push(await getBasicQuery(field2));
@@ -1139,14 +1148,14 @@ async function getBasicQuery(field) {
 // src/resolversSchemas/params.ts
 function getResultTypeName(type2) {
   const returns = Array.isArray(type2) ? type2[0] : type2;
-  const schema = getSchemaFromAnyOrionForm3(returns);
+  const schema = getSchemaFromAnyOrionForm4(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 (isSchemaLike4(returns)) {
-    const schema = getSchemaFromAnyOrionForm3(returns);
+    const schema = getSchemaFromAnyOrionForm4(returns);
     return await getBasicQuery({
       type: schema
     });
@@ -1165,21 +1174,21 @@ var params_default = createResolver({
   returns: ResolverParamsInfo_default,
   mutation: false,
   async resolve({ mutation, name }) {
-    const resolver2 = resolversStore[name];
-    if (!resolver2) {
+    const resolver = resolversStore[name];
+    if (!resolver) {
       throw new UserError(
         "notFound",
         `${mutation ? "Mutation" : "Query"} named "${name}" not found`
       );
     }
-    if (!!resolver2.mutation !== !!mutation) {
+    if (!!resolver.mutation !== !!mutation) {
       throw new 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)
     };
   }
 });
@@ -1203,7 +1212,9 @@ var OrionSubscription = class {
 
 // src/service/global.ts
 import { getInstance, Service } from "@orion-js/services";
-import { resolver } from "@orion-js/resolvers";
+import {
+  createResolver as createResolver2
+} from "@orion-js/resolvers";
 
 // src/service/middlewares.ts
 var resolversMetadata = /* @__PURE__ */ new WeakMap();
@@ -1246,99 +1257,134 @@ function ResolverReturns(returns) {
 }
 
 // src/service/global.ts
+var createQuery = createResolver2;
+var createMutation = (options) => {
+  return createResolver2({
+    ...options,
+    mutation: true
+  });
+};
 var serviceMetadata = /* @__PURE__ */ new WeakMap();
-var resolversMetadata2 = /* @__PURE__ */ new WeakMap();
+var internalResolversMetadata = /* @__PURE__ */ new WeakMap();
 function Resolvers() {
   return (target, context) => {
     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] = 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] = createResolver2({
+          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] = 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] = createResolver2({
+          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 = 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
 import { getInstance as getInstance2, Service as Service2 } from "@orion-js/services";
 import {
-  modelResolver
+  createModelResolver as createModelResolverFromResolvers
 } from "@orion-js/resolvers";
+var createModelResolver = createModelResolverFromResolvers;
 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;
+    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] = 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;
@@ -1375,8 +1421,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);
@@ -1386,10 +1432,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];
     });
@@ -1425,12 +1468,17 @@ export {
   Subscription,
   Subscriptions,
   UseMiddleware,
+  createModelResolver,
+  createMutation,
+  createQuery,
+  createResolver2 as createResolver,
   getBasicQuery as getBasicResultQuery,
   getServiceModelResolvers,
   getServiceResolvers,
   getServiceSubscriptions,
   getTargetMetadata,
   getWebsockerViewer,
+  internalResolversMetadata,
   resolversSchemas_default as resolversSchemas,
   serializeSchema,
   setGetWebsockerViewer,