@orion-js/graphql 4.3.1 → 4.4.0

package/dist/index.d.ts

@@ -1,172 +1,13 @@
-import * as _orion_js_resolvers from '@orion-js/resolvers';
-import { ResolverOptions, GlobalResolverOptions, GlobalResolver, ModelResolver as ModelResolver$1, 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, SchemaInAnyOrionForm } from '@orion-js/schema';
-import { ModelResolversMap, GlobalResolversMap } from '@orion-js/models';
-import { express } from '@orion-js/http';
-import { PubSubEngine } from 'graphql-subscriptions';
-import { ApolloServerOptions } from '@apollo/server';
-import * as graphql from 'graphql';
-export { graphql as GraphQL };
-
-declare class OrionSubscription<TParamsSchema extends SchemaFieldType = SchemaFieldType, TReturnsSchema extends SchemaFieldType = SchemaFieldType> {
-    name: string;
-    params: TParamsSchema;
-    subscribe: (callParams: InferSchemaType<TParamsSchema>, viewer: InferSchemaType<TReturnsSchema>) => {};
-    returns: TReturnsSchema;
-    publish: (params: InferSchemaType<TParamsSchema>, data: InferSchemaType<TReturnsSchema>) => Promise<void>;
-}
-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;
-}
-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>;
-};
-
-type ExecuteGraphQLCache = (req: express.Request, res: express.Response, viewer: object, executeQuery: () => Promise<string>) => Promise<string>;
-interface ModelsResolversMap {
-    [key: string]: ModelResolversMap;
-}
-type SchemaOmits = 'schema' | 'schemaHash' | 'context' | 'useGraphiql';
-interface StartGraphQLOptions extends Omit<ApolloServerOptions<any>, SchemaOmits> {
-    /**
-     * A map with all the global resolvers
-     */
-    resolvers: GlobalResolversMap;
-    /**
-     * A map with all the model resolvers. You must only add the models that you want to extend with resolvers.
-     */
-    modelResolvers?: ModelsResolversMap;
-    /**
-     * A Map with all global subscriptions
-     */
-    subscriptions?: OrionSubscriptionsMap;
-    /**
-     * A function that executes the http level cache of graphql queries
-     */
-    /**
-     * Should use GraphiQL. Default to true
-     */
-    useGraphiql?: boolean;
-    /**
-     * Pass another express app
-     */
-    app?: express.Application;
-    /**
-     * The pubsub provider to use. Default to the single server pubsub.
-     * If you are using multiple servers you must pass a pubsub provider like RedisPubSub
-     */
-    pubsub?: PubSubEngine;
-    /**
-     * Path to the graphql endpoint. Default to /graphql
-     */
-    path?: string;
-    /**
-     * Body parser options for the graphql endpoint.
-     */
-    bodyParserOptions?: {
-        limit?: number | string | undefined;
-    };
-}
-
-declare const createSubscription$1: CreateOrionSubscriptionFunction;
-
-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.GlobalResolver<{
-        name: {
-            type: "ID";
-        };
-        mutation: {
-            type: BooleanConstructor;
-        };
-    }, {
-        name: {
-            type: "string";
-        };
-        params: {
-            type: "blackbox";
-        };
-        result: {
-            type: "string";
-        };
-        basicResultQuery: {
-            type: "string";
-        };
-    }, any, any>;
-};
-
-declare const _default: {
-    name: {
-        type: "string";
-    };
-    params: {
-        type: "blackbox";
-    };
-    result: {
-        type: "string";
-    };
-    basicResultQuery: {
-        type: "string";
-    };
-};
-
-declare function serializeSchema(params: Schema): Promise<SchemaWithMetadata>;
-
-declare function getBasicQuery(field: SchemaNode): Promise<string>;
-
-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(): (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 registerPendingResolver(propertyKey: string, setup: (instance: any) => any): void;
-declare function getServiceResolvers(target: any): {
-    [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(): (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;
-    };
-};
-
-declare function Subscriptions(): (target: any, context: ClassDecoratorContext<any>) => void;
-declare function Subscription(): (method: any, context: ClassFieldDecoratorContext) => any;
-declare function getServiceSubscriptions(target: any): {
-    [key: string]: OrionSubscription;
-};
-
-declare function getTargetMetadata(target: any, propertyKey: string, metadataKey: string): any;
-declare function UseMiddleware<TMiddleware extends ResolverMiddleware, This>(params: TMiddleware): (method: any, context: ClassMethodDecoratorContext<This, typeof method>) => any;
-declare function ResolverParams<TParams extends SchemaInAnyOrionForm, This>(params: TParams): (method: any, context: ClassMethodDecoratorContext<This, typeof method>) => any;
-declare function ResolverReturns<This>(returns: any): (method: any, context: ClassMethodDecoratorContext<This, typeof method>) => any;
-
-declare const getWebsockerViewer: (connectionParams: any) => Promise<any>;
-declare const setGetWebsockerViewer: (getViewerFunc: (connectionParams: any) => any) => void;
-
-declare const createSubscription: CreateOrionSubscriptionFunction;
-
-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, createSubscription, getBasicQuery as getBasicResultQuery, getServiceModelResolvers, getServiceResolvers, getServiceSubscriptions, getTargetMetadata, getWebsockerViewer, internalResolversMetadata, registerPendingResolver, _default$1 as resolversSchemas, serializeSchema, setGetWebsockerViewer, export_default$1 as startGraphQL, export_default as startGraphiQL, createSubscription$1 as subscription };
+import subscription from './subscription';
+import startGraphQL from './startGraphQL';
+import startGraphiQL from './startGraphiQL';
+import resolversSchemas from './resolversSchemas';
+import ResolverParamsInfo from './resolversSchemas/ResolverParamsInfo';
+import serializeSchema from './resolversSchemas/serializeSchema';
+import getBasicResultQuery from './resolversSchemas/getBasicResultQuery';
+import * as GraphQL from 'graphql';
+declare const createSubscription: import("./types").CreateOrionSubscriptionFunction;
+export { GraphQL, startGraphQL, startGraphiQL, resolversSchemas, ResolverParamsInfo, serializeSchema, subscription, createSubscription, getBasicResultQuery, };
+export * from './types';
+export * from './service';
+export * from './websockerViewer';

package/dist/index.js

@@ -769,14 +769,16 @@ function getDynamicFields(schema) {
 // src/resolversSchemas/getModelLoadedResolvers.ts
 function getModelLoadedResolvers(schema, options) {
   if (!options.modelResolvers) return [];
+  if (!schema.__modelName) return [];
   const resolvers = options.modelResolvers[schema.__modelName];
   if (!resolvers) return [];
   const keys = Object.keys(resolvers);
   return keys.map((key) => {
     const resolver = resolvers[key];
-    resolver.resolverName = key;
+    const namedResolver = resolver;
+    namedResolver.resolverName = key;
     return {
-      ...resolver,
+      ...namedResolver,
       key
     };
   }).filter((resolver) => !resolver.private);
@@ -1095,8 +1097,34 @@ async function startGraphQL_default(options) {
 }
 
 // src/resolversSchemas/params.ts
-import { createResolver } from "@orion-js/resolvers";
 import { UserError } from "@orion-js/helpers";
+import { createResolver } from "@orion-js/resolvers";
+import {
+  getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm4,
+  isSchemaLike as isSchemaLike5
+} from "@orion-js/schema";
+
+// src/resolversSchemas/getBasicResultQuery.ts
+import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm2, isSchemaLike as isSchemaLike3 } from "@orion-js/schema";
+async function getBasicQuery(field) {
+  if (!field.type) return "";
+  if (Array.isArray(field.type)) {
+    return getBasicQuery({
+      ...field,
+      type: field.type[0]
+    });
+  }
+  if (!isSchemaLike3(field.type)) {
+    return field.key;
+  }
+  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/ResolverParamsInfo.ts
 import { schemaWithName } from "@orion-js/schema";
@@ -1116,13 +1144,13 @@ var ResolverParamsInfo_default = schemaWithName("ResolverParams", {
 });
 
 // src/resolversSchemas/serializeSchema.ts
-import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm2 } from "@orion-js/schema";
+import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm3 } from "@orion-js/schema";
 
 // src/resolversSchemas/getField.ts
 import {
   getFieldType as getFieldType3,
   getSchemaWithMetadataFromAnyOrionForm as getSchemaWithMetadataFromAnyOrionForm3,
-  isSchemaLike as isSchemaLike3
+  isSchemaLike as isSchemaLike4
 } from "@orion-js/schema";
 async function getParams(field) {
   const { type: type2 } = field;
@@ -1134,7 +1162,7 @@ async function getParams(field) {
       __graphQLType: `[${serialized.__graphQLType}]`
     };
   }
-  const isSchema = isSchemaLike3(type2);
+  const isSchema = isSchemaLike4(type2);
   if (isSchema) {
     const schemaOfType = getSchemaWithMetadataFromAnyOrionForm3(type2);
     const modelName = schemaOfType.__modelName;
@@ -1164,7 +1192,7 @@ async function getParams(field) {
 // src/resolversSchemas/serializeSchema.ts
 async function serializeSchema(params) {
   if (!params) return;
-  const schema = getSchemaFromAnyOrionForm2(params);
+  const schema = getSchemaFromAnyOrionForm3(params);
   if (Object.keys(schema).length === 0) return;
   const fields = {};
   for (const key of Object.keys(schema).filter((key2) => !key2.startsWith("__"))) {
@@ -1178,31 +1206,6 @@ async function serializeSchema(params) {
   return fields;
 }
 
-// src/resolversSchemas/params.ts
-import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm4, isSchemaLike as isSchemaLike5 } from "@orion-js/schema";
-
-// src/resolversSchemas/getBasicResultQuery.ts
-import { getSchemaFromAnyOrionForm as getSchemaFromAnyOrionForm3, isSchemaLike as isSchemaLike4 } from "@orion-js/schema";
-async function getBasicQuery(field) {
-  if (!field.type) return "";
-  if (Array.isArray(field.type)) {
-    return getBasicQuery({
-      ...field,
-      type: field.type[0]
-    });
-  }
-  if (!isSchemaLike4(field.type)) {
-    return field.key;
-  }
-  const schema = getSchemaFromAnyOrionForm3(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
 function getResultTypeName(type2) {
   const returns = Array.isArray(type2) ? type2[0] : type2;