@gqloom/core 0.2.1 → 0.3.0

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { GraphQLOutputType, GraphQLObjectTypeConfig, GraphQLFieldConfig, GraphQLResolveInfo, GraphQLScalarType, GraphQLObjectType, GraphQLUnionType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLSchemaConfig, GraphQLFieldMap, GraphQLNamedType, GraphQLSchema, GraphQLFieldConfigArgumentMap, GraphQLType, GraphQLInputType, GraphQLInterfaceTypeConfig, GraphQLFieldExtensions, GraphQLObjectTypeExtensions } from 'graphql';
+import { GraphQLOutputType, GraphQLObjectTypeConfig, GraphQLFieldConfig, GraphQLResolveInfo, GraphQLScalarType, GraphQLObjectType, GraphQLUnionType, GraphQLInterfaceType, GraphQLInputObjectType, GraphQLSchemaConfig, GraphQLFieldMap, GraphQLNamedType, GraphQLSchema, GraphQLFieldConfigArgumentMap, GraphQLType, GraphQLInputType, GraphQLInterfaceTypeConfig } from 'graphql';
 import { AsyncLocalStorage } from 'async_hooks';
 
 type MayPromise<T> = T | Promise<T>;
@@ -79,14 +79,19 @@ declare const RESOLVER_OPTIONS_KEY: unique symbol;
  * The symbol to assign a WeakMap to an object
  */
 declare const CONTEXT_MEMORY_MAP_KEY: unique symbol;
+/**
+ * The symbol to set fields to be hidden
+ */
+declare const FIELD_HIDDEN: unique symbol;
 
 declare const symbols_CONTEXT_MEMORY_MAP_KEY: typeof CONTEXT_MEMORY_MAP_KEY;
+declare const symbols_FIELD_HIDDEN: typeof FIELD_HIDDEN;
 declare const symbols_GET_GRAPHQL_TYPE: typeof GET_GRAPHQL_TYPE;
 declare const symbols_PARSE: typeof PARSE;
 declare const symbols_RESOLVER_OPTIONS_KEY: typeof RESOLVER_OPTIONS_KEY;
 declare const symbols_WEAVER_CONFIG: typeof WEAVER_CONFIG;
 declare namespace symbols {
-  export { symbols_CONTEXT_MEMORY_MAP_KEY as CONTEXT_MEMORY_MAP_KEY, symbols_GET_GRAPHQL_TYPE as GET_GRAPHQL_TYPE, symbols_PARSE as PARSE, symbols_RESOLVER_OPTIONS_KEY as RESOLVER_OPTIONS_KEY, symbols_WEAVER_CONFIG as WEAVER_CONFIG };
+  export { symbols_CONTEXT_MEMORY_MAP_KEY as CONTEXT_MEMORY_MAP_KEY, symbols_FIELD_HIDDEN as FIELD_HIDDEN, symbols_GET_GRAPHQL_TYPE as GET_GRAPHQL_TYPE, symbols_PARSE as PARSE, symbols_RESOLVER_OPTIONS_KEY as RESOLVER_OPTIONS_KEY, symbols_WEAVER_CONFIG as WEAVER_CONFIG };
 }
 
 interface GraphQLSilk<TOutput = any, TInput = any> {
@@ -159,10 +164,16 @@ interface QueryMutationOptions<TSchemaIO extends AbstractSchemaIO, TOutput exten
     resolve: (input: InferInputO<TInput, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>;
 }
 /**
- * Function to create a GraphQL query or mutation.
+ * Function to create a GraphQL query.
+ */
+interface QueryFactory<TSchemaIO extends AbstractSchemaIO> {
+    <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: (() => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | QueryMutationOptions<TSchemaIO, TOutput, TInput>): FieldOrOperation<undefined, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "query">;
+}
+/**
+ * Function to create a GraphQL mutation.
  */
-interface QueryMutationBobbin<TSchemaIO extends AbstractSchemaIO> {
-    <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: (() => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | QueryMutationOptions<TSchemaIO, TOutput, TInput>): FieldOrOperation<undefined, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "query" | "mutation">;
+interface MutationFactory<TSchemaIO extends AbstractSchemaIO> {
+    <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: (() => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | QueryMutationOptions<TSchemaIO, TOutput, TInput>): FieldOrOperation<undefined, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "mutation">;
 }
 /**
  * Options for External Filed of existing GraphQL Object.
@@ -174,9 +185,13 @@ interface FieldOptions<TSchemaIO extends AbstractSchemaIO, TParent extends TSche
 /**
  * Function to create a GraphQL Field.
  */
-interface FieldBobbin<TSchemaIO extends AbstractSchemaIO> {
+interface FieldFactory<TSchemaIO extends AbstractSchemaIO> {
     <TParent extends TSchemaIO[0], TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined>(output: TOutput, resolveOrOptions: ((parent: InferSchemaO<TParent, TSchemaIO>) => MayPromise<InferSchemaO<TOutput, TSchemaIO>>) | FieldOptions<TSchemaIO, TParent, TOutput, TInput>): FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, "field">;
 }
+interface FieldFactoryWithUtils<TSchemaIO extends AbstractSchemaIO> extends FieldFactory<TSchemaIO> {
+    /** Set fields to be hidden in GraphQL Schema */
+    hidden: typeof FIELD_HIDDEN;
+}
 /**
  * Options for creating a GraphQL Subscription.
  */
@@ -192,13 +207,14 @@ interface Subscription<TOutput extends GraphQLSilk, TInput extends InputSchema<G
 /**
  * Function to create a GraphQL subscription.
  */
-interface SubscriptionBobbin<TSchemaIO extends AbstractSchemaIO> {
+interface SubscriptionFactory<TSchemaIO extends AbstractSchemaIO> {
     <TOutput extends TSchemaIO[0], TInput extends InputSchema<TSchemaIO[0]> = undefined, TValue = InferSchemaO<TOutput, TSchemaIO>>(output: TOutput, subscribeOrOptions: (() => MayPromise<AsyncIterator<InferSchemaO<TOutput, TSchemaIO>>>) | SubscriptionOptions<TSchemaIO, TOutput, TInput, TValue>): Subscription<SchemaToSilk<TSchemaIO, TOutput>, InputSchemaToSilk<TSchemaIO, TInput>, TValue>;
 }
-interface ResolverBobbin<TSchemaIO extends AbstractSchemaIO> {
-    of<TParent extends TSchemaIO[0], TOperations extends Record<string, FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, any, any> | FieldOrOperation<undefined, any, any, OperationType>>>(parent: TParent, operationOrFields: TOperations, options?: ResolverOptionsWithExtensions<ValueOf<TOperations>>): TOperations;
+interface ResolverFactory<TSchemaIO extends AbstractSchemaIO> {
+    of<TParent extends TSchemaIO[0], TOperations extends Record<string, FieldOrOperation<SchemaToSilk<TSchemaIO, TParent>, any, any> | FieldOrOperation<undefined, any, any, OperationType> | typeof FIELD_HIDDEN>>(parent: TParent, operationOrFields: TOperations, options?: ResolverOptionsWithExtensions<OmitInUnion<ValueOf<TOperations>, typeof FIELD_HIDDEN>>): TOperations;
     <TOperations extends Record<string, FieldOrOperation<undefined, any, any, OperationType>>>(operations: TOperations, options?: ResolverOptions<ValueOf<TOperations>>): TOperations;
 }
+type OmitInUnion<TUnion, TOmit> = TUnion extends infer T ? T extends TOmit ? never : T : never;
 
 declare function getOperationOptions<T extends FieldOrOperationType = OperationType>(resolveOrOptions: T extends "field" ? ((parent: any) => any) | FieldOptions<any, any, any, any> : (() => any) | QueryMutationOptions<any, any, any>): T extends "field" ? FieldOptions<any, any, any, any> : QueryMutationOptions<any, any, any>;
 declare function getSubscriptionOptions(subscribeOrOptions: (() => any) | SubscriptionOptions<any, any, any, any>): SubscriptionOptions<any, any, any, any>;
@@ -359,11 +375,11 @@ declare function markLocation(message: string, ...locations: string[]): string;
 /**
  * Create a Silk from Scalar.
  */
-declare function silk<TScalar extends GraphQLScalarType>(type: TScalar, parse?: (input: InferScalarExternal<TScalar>) => MayPromise<InferScalarInternal<TScalar>>): GraphQLSilk<InferScalarInternal<TScalar> | undefined, InferScalarInternal<TScalar> | undefined>;
+declare function silk<TScalar extends GraphQLScalarType>(type: TScalar | (() => TScalar), parse?: (input: InferScalarExternal<TScalar>) => MayPromise<InferScalarInternal<TScalar>>): GraphQLSilk<InferScalarInternal<TScalar> | undefined, InferScalarInternal<TScalar> | undefined>;
 /**
  * Create a GraphQLSilk Object.
  */
-declare function silk<TOutput, TInput = TOutput>(type: GraphQLOutputType, parse?: (input: TInput) => MayPromise<TOutput>): GraphQLSilk<TOutput, TInput>;
+declare function silk<TOutput, TInput = TOutput>(type: GraphQLOutputType | (() => GraphQLOutputType), parse?: (input: TInput) => MayPromise<TOutput>): GraphQLSilk<TOutput, TInput>;
 declare namespace silk {
     var parse: typeof parseSilk;
     var getType: typeof getGraphQLType;
@@ -404,36 +420,37 @@ type InferScalarInternal<T extends GraphQLScalarType> = T extends GraphQLScalarT
 type InferScalarExternal<T extends GraphQLScalarType> = T extends GraphQLScalarType<any, infer TExternal> ? TExternal : never;
 type EnsureArray<T> = T extends Array<infer U> ? U[] : T[];
 
-declare const silkQuery: QueryMutationBobbin<GraphQLSilkIO>;
-declare const silkMutation: QueryMutationBobbin<GraphQLSilkIO>;
-declare const silkField: FieldBobbin<GraphQLSilkIO>;
+declare const silkQuery: QueryFactory<GraphQLSilkIO>;
+declare const silkMutation: MutationFactory<GraphQLSilkIO>;
+declare const silkField: FieldFactoryWithUtils<GraphQLSilkIO>;
 declare const defaultSubscriptionResolve: (source: any) => any;
-declare const silkSubscription: SubscriptionBobbin<GraphQLSilkIO>;
+declare const silkSubscription: SubscriptionFactory<GraphQLSilkIO>;
 declare const ResolverOptionsMap: WeakMap<object, ResolverOptionsWithParent<GenericFieldOrOperation>>;
 declare function baseResolver(operations: Record<string, FieldOrOperation<any, any, any>>, options: ResolverOptionsWithParent | undefined): Record<string, FieldOrOperation<any, any, any, FieldOrOperationType>>;
-declare const silkResolver: ResolverBobbin<GraphQLSilkIO>;
+declare const silkResolver: ResolverFactory<GraphQLSilkIO>;
 declare const loom: {
-    query: QueryMutationBobbin<GraphQLSilkIO>;
-    resolver: ResolverBobbin<GraphQLSilkIO>;
-    field: FieldBobbin<GraphQLSilkIO>;
-    subscription: SubscriptionBobbin<GraphQLSilkIO>;
-    mutation: QueryMutationBobbin<GraphQLSilkIO>;
+    query: QueryFactory<GraphQLSilkIO>;
+    resolver: ResolverFactory<GraphQLSilkIO>;
+    field: FieldFactoryWithUtils<GraphQLSilkIO>;
+    subscription: SubscriptionFactory<GraphQLSilkIO>;
+    mutation: MutationFactory<GraphQLSilkIO>;
 };
 
-declare function createResolverBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk): ResolverBobbin<TSchemaIO>;
-declare function createFieldBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): FieldBobbin<TSchemaIO>;
-declare function createQueryBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): QueryMutationBobbin<TSchemaIO>;
-declare function createMutationBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): QueryMutationBobbin<TSchemaIO>;
-declare function createSubscriptionBobbin<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): SubscriptionBobbin<TSchemaIO>;
+declare function createResolverFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk): ResolverFactory<TSchemaIO>;
+declare function createFieldFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): FieldFactoryWithUtils<TSchemaIO>;
+declare function createQueryFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): QueryFactory<TSchemaIO>;
+declare function createMutationFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): MutationFactory<TSchemaIO>;
+declare function createSubscriptionFactory<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): SubscriptionFactory<TSchemaIO>;
 declare function createLoom<TSchemaIO extends AbstractSchemaIO>(toSilk: (schema: TSchemaIO[0]) => GraphQLSilk, isSchema: (schema: InputSchema<TSchemaIO[0]>) => boolean): {
-    query: QueryMutationBobbin<TSchemaIO>;
-    mutation: QueryMutationBobbin<TSchemaIO>;
-    field: FieldBobbin<TSchemaIO>;
-    resolver: ResolverBobbin<TSchemaIO>;
-    subscription: SubscriptionBobbin<TSchemaIO>;
+    query: QueryFactory<TSchemaIO>;
+    mutation: MutationFactory<TSchemaIO>;
+    field: FieldFactoryWithUtils<TSchemaIO>;
+    resolver: ResolverFactory<TSchemaIO>;
+    subscription: SubscriptionFactory<TSchemaIO>;
 };
 
 interface WeaverContext {
+    id: number;
     loomObjectMap: Map<GraphQLObjectType, LoomObjectType>;
     loomUnionMap: Map<GraphQLUnionType, GraphQLUnionType>;
     inputMap: Map<GraphQLObjectType | GraphQLInterfaceType, GraphQLInputObjectType>;
@@ -451,6 +468,9 @@ interface WeaverConfig {
     [WEAVER_CONFIG]: string | symbol;
 }
 declare function initWeaverContext(): WeaverContext;
+declare namespace initWeaverContext {
+    var increasingID: number;
+}
 type GlobalContextRequiredKeys = "names" | "getConfig" | "setConfig" | "getNamedType" | "memoNamedType";
 interface GlobalWeaverContext extends Partial<Omit<WeaverContext, GlobalContextRequiredKeys>>, Pick<WeaverContext, GlobalContextRequiredKeys> {
     value?: WeaverContext;
@@ -461,19 +481,29 @@ interface GlobalWeaverContext extends Partial<Omit<WeaverContext, GlobalContextR
 }
 declare const weaverContext: GlobalWeaverContext;
 declare function provideWeaverContext<T>(func: () => T, value: WeaverContext | undefined): T;
+declare namespace provideWeaverContext {
+    var inherit: <T>(func: () => T) => () => T;
+}
 /**
  * collect names for schemas
  * @param namesList - names to collect
  * @returns namesRecord
  */
 declare function collectNames<TRecords extends Record<string, object>[]>(...namesList: TRecords): UnionToIntersection<TRecords[number]>;
+/**
+ * collect name for schema
+ * @param name - name for
+ * @param schema - schema to be named
+ * @returns schema
+ */
+declare function collectName<TSchema extends object>(name: string, schema: TSchema): TSchema;
 type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends (k: infer I) => void ? I : never;
 
 type SilkFieldOrOperation = FieldOrOperation<any, any, any, any>;
 interface FieldConvertOptions {
     optionsForResolving?: ResolvingOptions;
 }
-type SilkResolver = Record<string, FieldOrOperation<any, any, any, any>>;
+type SilkResolver = Record<string, FieldOrOperation<any, any, any, any> | typeof FIELD_HIDDEN>;
 interface CoreSchemaWeaverConfigOptions extends GraphQLSchemaConfig {
     getInputObjectName?: (name: string) => string;
     weaverContext?: WeaverContext;
@@ -483,16 +513,18 @@ interface CoreSchemaWeaverConfig extends WeaverConfig, CoreSchemaWeaverConfigOpt
 }
 
 declare class LoomObjectType extends GraphQLObjectType {
-    extraFields: Map<string, SilkFieldOrOperation>;
-    weaverContext: WeaverContext;
-    resolverOptions?: ResolvingOptions;
+    protected extraFields: Map<string, SilkFieldOrOperation>;
+    protected hiddenFields: Set<string>;
+    protected weaverContext: WeaverContext;
+    protected resolverOptions?: ResolvingOptions;
     constructor(objectOrGetter: string | GraphQLObjectType | GraphQLObjectTypeConfig<any, any> | (() => GraphQLObjectType | GraphQLObjectTypeConfig<any, any>), options?: {
         weaverContext?: WeaverContext;
         resolverOptions?: ResolvingOptions;
     });
+    hideField(name: string): void;
     addField(name: string, resolver: SilkFieldOrOperation): void;
     mergeExtensions(extensions: GraphQLObjectTypeConfig<any, any>["extensions"]): void;
-    private extraField?;
+    private extraFieldMap?;
     getFields(): GraphQLFieldMap<any, any>;
     protected mapToFieldConfig(map: Map<string, SilkFieldOrOperation>): Record<string, GraphQLFieldConfig<any, any>>;
     toFieldConfig(field: SilkFieldOrOperation): GraphQLFieldConfig<any, any>;
@@ -576,6 +608,5 @@ type DirectiveRecord = Record<string, Record<string, any>>;
 interface GQLoomExtensionAttribute {
     directives?: string[];
 }
-declare function mergeExtensions(...extensionsList: (Readonly<GraphQLFieldExtensions<any, any, any> | GraphQLObjectTypeExtensions | GQLoomExtensions> | null | undefined)[]): GraphQLFieldExtensions<any, any, any>;
 
-export { type AbstractSchemaIO, type CallableContextMemoization, type CallableInputParser, ContextMemoization, type CoreSchemaWeaverConfig, type CoreSchemaWeaverConfigOptions, type DirectiveItem, type DirectiveRecord, type FieldBobbin, type FieldConvertOptions, type FieldOptions, type FieldOrOperation, type FieldOrOperationType, type GQLoomExtensionAttribute, type GQLoomExtensions, type GenericFieldOrOperation, type GlobalWeaverContext, type GraphQLFieldOptions, type GraphQLSilk, type GraphQLSilkIO, type InferFieldInput, type InferFieldOutput, type InferFieldParent, type InferInputI, type InferInputO, type InferPropertyType, type InferSchemaI, type InferSchemaO, type InferSilkI, type InferSilkO, type InputSchema, type InputSchemaToSilk, type IsAny, type ListSilk, LoomObjectType, type MayPromise, type Middleware, type MiddlewarePayload, type NonNullSilk, type NullableSilk, type ObjectOrNever, type OnlyMemoizationPayload, type OperationType, type QueryMutationBobbin, type QueryMutationOptions, type ResolverBobbin, type ResolverOptions, ResolverOptionsMap, type ResolverOptionsWithExtensions, type ResolverOptionsWithParent, type ResolverPayload, type ResolvingOptions, symbols as SYMBOLS, type SchemaToSilk, SchemaWeaver, type SilkFieldOrOperation, type SilkResolver, type Subscription, type SubscriptionBobbin, type SubscriptionOptions, type ValueOf, type WeaverConfig, type WeaverContext, type WrapPropertyType, applyMiddlewares, baseResolver, collectNames, compose, createFieldBobbin, createInputParser, createLoom, createMemoization, createMutationBobbin, createQueryBobbin, createResolverBobbin, createSubscriptionBobbin, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, getCacheType, getFieldOptions, getGraphQLType, getOperationOptions, getSubscriptionOptions, initWeaverContext, inputToArgs, isOnlyMemoryPayload, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, mergeExtensions, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseSilk, provideWeaverContext, resolverPayloadStorage, silk, silkField, silkMutation, silkQuery, silkResolver, silkSubscription, toObjMap, tryIn, useContext, useMemoizationMap, useResolverPayload, weave, weaverContext };
+export { type AbstractSchemaIO, type CallableContextMemoization, type CallableInputParser, ContextMemoization, type CoreSchemaWeaverConfig, type CoreSchemaWeaverConfigOptions, type DirectiveItem, type DirectiveRecord, type FieldConvertOptions, type FieldFactory, type FieldFactoryWithUtils, type FieldOptions, type FieldOrOperation, type FieldOrOperationType, type GQLoomExtensionAttribute, type GQLoomExtensions, type GenericFieldOrOperation, type GlobalWeaverContext, type GraphQLFieldOptions, type GraphQLSilk, type GraphQLSilkIO, type InferFieldInput, type InferFieldOutput, type InferFieldParent, type InferInputI, type InferInputO, type InferPropertyType, type InferSchemaI, type InferSchemaO, type InferSilkI, type InferSilkO, type InputSchema, type InputSchemaToSilk, type IsAny, type ListSilk, LoomObjectType, type MayPromise, type Middleware, type MiddlewarePayload, type MutationFactory, type NonNullSilk, type NullableSilk, type ObjectOrNever, type OnlyMemoizationPayload, type OperationType, type QueryFactory, type QueryMutationOptions, type ResolverFactory, type ResolverOptions, ResolverOptionsMap, type ResolverOptionsWithExtensions, type ResolverOptionsWithParent, type ResolverPayload, type ResolvingOptions, symbols as SYMBOLS, type SchemaToSilk, SchemaWeaver, type SilkFieldOrOperation, type SilkResolver, type Subscription, type SubscriptionFactory, type SubscriptionOptions, type ValueOf, type WeaverConfig, type WeaverContext, type WrapPropertyType, applyMiddlewares, baseResolver, collectName, collectNames, compose, createFieldFactory, createInputParser, createLoom, createMemoization, createMutationFactory, createQueryFactory, createResolverFactory, createSubscriptionFactory, deepMerge, defaultSubscriptionResolve, ensureInputObjectType, ensureInputType, ensureInterfaceType, getCacheType, getFieldOptions, getGraphQLType, getOperationOptions, getSubscriptionOptions, initWeaverContext, inputToArgs, isOnlyMemoryPayload, isSilk, listSilk, loom, mapValue, markErrorLocation, markLocation, nonNullSilk, notNullish, nullableSilk, onlyMemoization, parseInputValue, parseSilk, provideWeaverContext, resolverPayloadStorage, silk, silkField, silkMutation, silkQuery, silkResolver, silkSubscription, toObjMap, tryIn, useContext, useMemoizationMap, useResolverPayload, weave, weaverContext };

package/dist/index.js

@@ -14,6 +14,7 @@ import {
 var symbols_exports = {};
 __export(symbols_exports, {
   CONTEXT_MEMORY_MAP_KEY: () => CONTEXT_MEMORY_MAP_KEY,
+  FIELD_HIDDEN: () => FIELD_HIDDEN,
   GET_GRAPHQL_TYPE: () => GET_GRAPHQL_TYPE,
   PARSE: () => PARSE,
   RESOLVER_OPTIONS_KEY: () => RESOLVER_OPTIONS_KEY,
@@ -24,6 +25,7 @@ var PARSE = Symbol.for("gqloom.parse");
 var WEAVER_CONFIG = Symbol.for("gqloom.weaver_config");
 var RESOLVER_OPTIONS_KEY = Symbol.for("gqloom.resolver-options");
 var CONTEXT_MEMORY_MAP_KEY = Symbol.for("gqloom.context-memory");
+var FIELD_HIDDEN = Symbol.for("gqloom.field-hidden");
 
 // src/resolver/silk.ts
 function silk(type, parse) {
@@ -381,7 +383,7 @@ var silkMutation = (output, resolveOrOptions) => {
     type
   };
 };
-var silkField = (output, resolveOrOptions) => {
+var baseSilkField = (output, resolveOrOptions) => {
   const options = getOperationOptions(resolveOrOptions);
   const type = "field";
   return {
@@ -399,6 +401,12 @@ var silkField = (output, resolveOrOptions) => {
     type
   };
 };
+var silkField = Object.assign(
+  baseSilkField,
+  {
+    hidden: FIELD_HIDDEN
+  }
+);
 var defaultSubscriptionResolve = (source) => source;
 var silkSubscription = (output, subscribeOrOptions) => {
   const options = getSubscriptionOptions(subscribeOrOptions);
@@ -433,6 +441,7 @@ function baseResolver(operations, options) {
 }
 function extraOperationOptions(operation, options) {
   const composeMiddlewares = (extraOptions) => compose(extraOptions?.middlewares, options?.middlewares);
+  if (typeof operation === "symbol") return operation;
   switch (operation.type) {
     case "field":
       return {
@@ -491,7 +500,7 @@ function toSilkInput(schema, toSilk, isSchema) {
   }
   return record;
 }
-function createResolverBobbin(toSilk) {
+function createResolverFactory(toSilk) {
   return Object.assign(baseResolver, {
     of: (parent, operations, options) => baseResolver(
       operations,
@@ -499,8 +508,8 @@ function createResolverBobbin(toSilk) {
     )
   });
 }
-function createFieldBobbin(toSilk, isSchema) {
-  return (output, resolveOrOptions) => {
+function createFieldFactory(toSilk, isSchema) {
+  const baseFieldFunc = (output, resolveOrOptions) => {
     const options = getOperationOptions(
       resolveOrOptions
     );
@@ -509,8 +518,11 @@ function createFieldBobbin(toSilk, isSchema) {
       input: toSilkInput(options.input, toSilk, isSchema)
     });
   };
+  return Object.assign(baseFieldFunc, {
+    hidden: FIELD_HIDDEN
+  });
 }
-function createQueryBobbin(toSilk, isSchema) {
+function createQueryFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
     const options = getOperationOptions(resolveOrOptions);
     return silkQuery(toSilk(output), {
@@ -519,7 +531,7 @@ function createQueryBobbin(toSilk, isSchema) {
     });
   };
 }
-function createMutationBobbin(toSilk, isSchema) {
+function createMutationFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
     const options = getOperationOptions(resolveOrOptions);
     return silkMutation(toSilk(output), {
@@ -528,7 +540,7 @@ function createMutationBobbin(toSilk, isSchema) {
     });
   };
 }
-function createSubscriptionBobbin(toSilk, isSchema) {
+function createSubscriptionFactory(toSilk, isSchema) {
   return (output, resolveOrOptions) => {
     const options = getSubscriptionOptions(resolveOrOptions);
     return silkSubscription(toSilk(output), {
@@ -539,11 +551,11 @@ function createSubscriptionBobbin(toSilk, isSchema) {
 }
 function createLoom(toSilk, isSchema) {
   return {
-    query: createQueryBobbin(toSilk, isSchema),
-    mutation: createMutationBobbin(toSilk, isSchema),
-    field: createFieldBobbin(toSilk, isSchema),
-    resolver: createResolverBobbin(toSilk),
-    subscription: createSubscriptionBobbin(toSilk, isSchema)
+    query: createQueryFactory(toSilk, isSchema),
+    mutation: createMutationFactory(toSilk, isSchema),
+    field: createFieldFactory(toSilk, isSchema),
+    resolver: createResolverFactory(toSilk),
+    subscription: createSubscriptionFactory(toSilk, isSchema)
   };
 }
 
@@ -565,12 +577,14 @@ import {
 import {
   isEnumType,
   isObjectType,
-  isUnionType
+  isUnionType,
+  isScalarType
 } from "graphql";
 var ref;
 var names = /* @__PURE__ */ new WeakMap();
 function initWeaverContext() {
   return {
+    id: initWeaverContext.increasingID++,
     loomObjectMap: /* @__PURE__ */ new Map(),
     loomUnionMap: /* @__PURE__ */ new Map(),
     inputMap: /* @__PURE__ */ new Map(),
@@ -590,7 +604,7 @@ function initWeaverContext() {
     namedTypes: /* @__PURE__ */ new Map(),
     memoNamedType(gqlTypeValue) {
       const gqlType = gqlTypeValue;
-      if (isObjectType(gqlType) || isUnionType(gqlType) || isEnumType(gqlType)) {
+      if (isObjectType(gqlType) || isUnionType(gqlType) || isEnumType(gqlType) || isScalarType(gqlType)) {
         this.namedTypes.set(gqlType.name, gqlType);
       }
       return gqlTypeValue;
@@ -600,7 +614,11 @@ function initWeaverContext() {
     }
   };
 }
+initWeaverContext.increasingID = 1;
 var weaverContext = {
+  get id() {
+    return ref?.id;
+  },
   get loomObjectMap() {
     return ref?.loomObjectMap;
   },
@@ -660,6 +678,10 @@ function provideWeaverContext(func, value) {
     ref = lastRef;
   }
 }
+provideWeaverContext.inherit = (func) => {
+  const weaverContextRef = weaverContext.value;
+  return () => provideWeaverContext(func, weaverContextRef);
+};
 function collectNames(...namesList) {
   const namesRecord = {};
   for (const namesItem of namesList) {
@@ -670,6 +692,10 @@ function collectNames(...namesList) {
   }
   return namesRecord;
 }
+function collectName(name, schema) {
+  names.set(schema, name);
+  return schema;
+}
 
 // src/schema/input.ts
 import {
@@ -740,7 +766,9 @@ function ensureInputObjectType(object) {
   const input = new GraphQLInputObjectType({
     ...config,
     name: getInputObjectName(object.name),
-    fields: mapValue(fields, (it) => toInputFieldConfig(it))
+    fields: provideWeaverContext.inherit(
+      () => mapValue(fields, (it) => toInputFieldConfig(it))
+    )
   });
   weaverContext.inputMap?.set(object, input);
   return input;
@@ -756,6 +784,7 @@ function toInputFieldConfig({
 // src/schema/object.ts
 var LoomObjectType = class extends GraphQLObjectType {
   extraFields = /* @__PURE__ */ new Map();
+  hiddenFields = /* @__PURE__ */ new Set();
   weaverContext;
   resolverOptions;
   constructor(objectOrGetter, options = {}) {
@@ -773,6 +802,9 @@ var LoomObjectType = class extends GraphQLObjectType {
     this.resolverOptions = options.resolverOptions;
     this.weaverContext = options.weaverContext ?? initWeaverContext();
   }
+  hideField(name) {
+    this.hiddenFields.add(name);
+  }
   addField(name, resolver) {
     const existing = this.extraFields.get(name);
     if (existing && existing !== resolver) {
@@ -783,23 +815,27 @@ var LoomObjectType = class extends GraphQLObjectType {
   mergeExtensions(extensions) {
     this.extensions = deepMerge(this.extensions, extensions);
   }
-  extraField;
+  extraFieldMap;
   getFields() {
-    const fields = super.getFields();
-    Object.values(fields).forEach(
+    const fieldsBySuper = super.getFields();
+    Object.values(fieldsBySuper).forEach(
       (field) => field.type = this.getCacheType(field.type)
     );
-    const extraField = provideWeaverContext(
+    const extraFields = provideWeaverContext(
       () => defineFieldMap(this.mapToFieldConfig(this.extraFields)),
       this.weaverContext
     );
-    if (Object.keys(this.extraField ?? {}).join() !== Object.keys(extraField).join()) {
-      this.extraField = extraField;
+    if (Object.keys(this.extraFieldMap ?? {}).join() !== Object.keys(extraFields).join()) {
+      this.extraFieldMap = extraFields;
     }
-    return {
-      ...fields,
-      ...this.extraField
+    const answer = {
+      ...fieldsBySuper,
+      ...this.extraFieldMap
     };
+    for (const fieldName of this.hiddenFields) {
+      delete answer[fieldName];
+    }
+    return answer;
   }
   mapToFieldConfig(map) {
     const record = {};
@@ -1024,7 +1060,10 @@ var SchemaWeaver = class _SchemaWeaver {
     if (resolverOptions?.extensions && parentObject)
       parentObject.mergeExtensions(resolverOptions.extensions);
     Object.entries(resolver).forEach(([name, operation]) => {
-      if (operation.type === "field") {
+      if (operation === FIELD_HIDDEN) {
+        if (parentObject == null) return;
+        parentObject.hideField(name);
+      } else if (operation.type === "field") {
         if (parentObject == null) return;
         parentObject.addField(name, operation);
       } else {
@@ -1131,11 +1170,6 @@ function ensureInterfaceType(gqlType, interfaceConfig) {
   weaverContext.interfaceMap?.set(key, interfaceType);
   return interfaceType;
 }
-
-// src/schema/extensions.ts
-function mergeExtensions(...extensionsList) {
-  return deepMerge(...extensionsList);
-}
 export {
   ContextMemoization,
   LoomObjectType,
@@ -1144,16 +1178,17 @@ export {
   SchemaWeaver,
   applyMiddlewares,
   baseResolver,
+  collectName,
   collectNames,
   compose,
-  createFieldBobbin,
+  createFieldFactory,
   createInputParser,
   createLoom,
   createMemoization,
-  createMutationBobbin,
-  createQueryBobbin,
-  createResolverBobbin,
-  createSubscriptionBobbin,
+  createMutationFactory,
+  createQueryFactory,
+  createResolverFactory,
+  createSubscriptionFactory,
   deepMerge,
   defaultSubscriptionResolve,
   ensureInputObjectType,
@@ -1173,7 +1208,6 @@ export {
   mapValue,
   markErrorLocation,
   markLocation,
-  mergeExtensions,
   nonNullSilk,
   notNullish,
   nullableSilk,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gqloom/core",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Create GraphQL schema and resolvers with TypeScript.",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,7 +18,8 @@
     }
   },
   "scripts": {
-    "build": "tsup"
+    "build": "tsup",
+    "release": "commit-and-tag-version"
   },
   "files": [
     "dist"
@@ -26,9 +27,23 @@
   "peerDependencies": {
     "graphql": ">= 16.8.0"
   },
-  "keywords": [],
+  "keywords": [
+    "gqloom",
+    "graphql",
+    "schema",
+    "typescript",
+    "valibot",
+    "zod",
+    "yup"
+  ],
   "author": "xcfox",
   "license": "MIT",
+  "homepage": "https://gqloom.dev/",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/modevol-com/gqloom.git",
+    "directory": "packages/core"
+  },
   "publishConfig": {
     "access": "public"
   }