@omnigraph/json-schema 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/esm/utils.js

@@ -0,0 +1,57 @@
+export function isPubSubOperationConfig(operationConfig) {
+    return 'pubsubTopic' in operationConfig;
+}
+export function getOperationMetadata(operationConfig) {
+    let httpMethod;
+    let operationType;
+    let rootTypeName;
+    if (isPubSubOperationConfig(operationConfig)) {
+        httpMethod = null;
+        operationType = 'subscription';
+        rootTypeName = 'Subscription';
+    }
+    else {
+        httpMethod = operationConfig.method;
+        // Fix compability with Mesh handler
+        operationType = operationConfig.type.toLowerCase();
+        if (!httpMethod) {
+            if (operationType === 'mutation') {
+                httpMethod = 'POST';
+            }
+            else {
+                httpMethod = 'GET';
+            }
+        }
+        if (!rootTypeName) {
+            if (httpMethod === 'GET') {
+                rootTypeName = 'Query';
+            }
+        }
+        rootTypeName = operationType === 'query' ? 'Query' : 'Mutation';
+    }
+    return {
+        httpMethod,
+        operationType,
+        rootTypeName,
+        fieldName: operationConfig.field,
+    };
+}
+export function cleanObject(obj) {
+    if (typeof obj === 'object' && obj != null) {
+        const newObj = Array.isArray(obj) ? [] : {};
+        for (const key in obj) {
+            const newObjForKey = cleanObject(obj[key]);
+            if (newObjForKey != null) {
+                newObj[key] = newObjForKey;
+            }
+        }
+        return newObj;
+    }
+    return obj;
+}
+export function isFileUpload(obj) {
+    return typeof obj.createReadStream === 'function';
+}
+export function isFile(obj) {
+    return typeof obj.arrayBuffer === 'function';
+}

package/package.json

@@ -1,28 +1,28 @@
 {
   "name": "@omnigraph/json-schema",
-  "version": "1.0.0-alpha-3fc47d119.0",
+  "version": "1.0.0-alpha-20230420181317-a95037648",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "0.79.0-alpha-3fc47d119.0",
-    "@graphql-mesh/utils": "1.0.0-alpha-3fc47d119.0",
-    "graphql": "*"
+    "@graphql-mesh/cross-helpers": "^0.3.4",
+    "@graphql-mesh/types": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
-    "@graphql-mesh/cross-helpers": "0.2.0",
-    "@graphql-mesh/string-interpolation": "0.3.0",
-    "@graphql-tools/utils": "8.8.0",
-    "@json-schema-tools/meta-schema": "1.6.19",
-    "@whatwg-node/fetch": "^0.0.2",
-    "ajv": "8.11.0",
+    "@graphql-mesh/string-interpolation": "0.4.4",
+    "@json-schema-tools/meta-schema": "1.7.0",
+    "@whatwg-node/fetch": "^0.8.3",
+    "ajv": "8.12.0",
     "ajv-formats": "2.1.1",
-    "graphql-compose": "9.0.8",
-    "graphql-scalars": "1.17.0",
-    "json-machete": "1.0.0-alpha-3fc47d119.0",
-    "lodash.set": "4.3.2",
+    "dset": "3.1.2",
+    "graphql-compose": "9.0.10",
+    "graphql-scalars": "^1.20.4",
+    "json-machete": "1.0.0-alpha-20230420181317-a95037648",
     "pascal-case": "3.1.2",
-    "qs": "6.11.0",
+    "qs": "6.11.1",
     "to-json-schema": "0.2.5",
-    "tslib": "^2.4.0",
     "url-join": "4.0.1"
   },
   "repository": {
@@ -31,21 +31,28 @@
     "directory": "packages/loaders/json-schema"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/addExecutionLogicToComposer.d.cts

@@ -0,0 +1,14 @@
+import { SchemaComposer } from 'graphql-compose';
+import { IStringifyOptions } from 'qs';
+import { Logger } from '@graphql-mesh/types';
+import { JSONSchemaOperationConfig, OperationHeadersConfiguration } from './types.cjs';
+export interface AddExecutionLogicToComposerOptions {
+    schemaComposer: SchemaComposer;
+    endpoint: string;
+    operations: JSONSchemaOperationConfig[];
+    operationHeaders?: OperationHeadersConfiguration;
+    logger: Logger;
+    queryParams?: Record<string, string | number | boolean>;
+    queryStringOptions?: IStringifyOptions;
+}
+export declare function addExecutionDirectivesToComposer(name: string, { schemaComposer, logger, operations, operationHeaders, endpoint, queryParams, queryStringOptions, }: AddExecutionLogicToComposerOptions): Promise<SchemaComposer<any>>;

package/typings/addExecutionLogicToComposer.d.ts

@@ -0,0 +1,14 @@
+import { SchemaComposer } from 'graphql-compose';
+import { IStringifyOptions } from 'qs';
+import { Logger } from '@graphql-mesh/types';
+import { JSONSchemaOperationConfig, OperationHeadersConfiguration } from './types.js';
+export interface AddExecutionLogicToComposerOptions {
+    schemaComposer: SchemaComposer;
+    endpoint: string;
+    operations: JSONSchemaOperationConfig[];
+    operationHeaders?: OperationHeadersConfiguration;
+    logger: Logger;
+    queryParams?: Record<string, string | number | boolean>;
+    queryStringOptions?: IStringifyOptions;
+}
+export declare function addExecutionDirectivesToComposer(name: string, { schemaComposer, logger, operations, operationHeaders, endpoint, queryParams, queryStringOptions, }: AddExecutionLogicToComposerOptions): Promise<SchemaComposer<any>>;

package/typings/addRootFieldResolver.d.cts

@@ -0,0 +1,26 @@
+import { GraphQLField, GraphQLSchema } from 'graphql';
+import { IStringifyOptions } from 'qs';
+import { Logger, MeshFetch } from '@graphql-mesh/types';
+import { HTTPMethod } from './types.cjs';
+export interface HTTPRootFieldResolverOpts {
+    sourceName: string;
+    endpoint: string;
+    path: string;
+    httpMethod: HTTPMethod;
+    operationSpecificHeaders: Record<string, string>;
+    isBinary: boolean;
+    requestBaseBody: any;
+    queryParamArgMap: Record<string, string>;
+    queryStringOptionsByParam: Record<string, IStringifyOptions & {
+        destructObject?: boolean;
+    }>;
+}
+export interface GlobalOptions {
+    sourceName: string;
+    endpoint: string;
+    timeout: number;
+    operationHeaders: Record<string, string>;
+    queryStringOptions: IStringifyOptions;
+    queryParams: Record<string, string | number | boolean>;
+}
+export declare function addHTTPRootFieldResolver(schema: GraphQLSchema, field: GraphQLField<any, any>, logger: Logger, globalFetch: MeshFetch, { path, operationSpecificHeaders, httpMethod, isBinary, requestBaseBody, queryParamArgMap, queryStringOptionsByParam, }: HTTPRootFieldResolverOpts, { sourceName, endpoint, timeout, operationHeaders: globalOperationHeaders, queryStringOptions: globalQueryStringOptions, queryParams: globalQueryParams, }: GlobalOptions): void;

package/typings/addRootFieldResolver.d.ts

@@ -0,0 +1,26 @@
+import { GraphQLField, GraphQLSchema } from 'graphql';
+import { IStringifyOptions } from 'qs';
+import { Logger, MeshFetch } from '@graphql-mesh/types';
+import { HTTPMethod } from './types.js';
+export interface HTTPRootFieldResolverOpts {
+    sourceName: string;
+    endpoint: string;
+    path: string;
+    httpMethod: HTTPMethod;
+    operationSpecificHeaders: Record<string, string>;
+    isBinary: boolean;
+    requestBaseBody: any;
+    queryParamArgMap: Record<string, string>;
+    queryStringOptionsByParam: Record<string, IStringifyOptions & {
+        destructObject?: boolean;
+    }>;
+}
+export interface GlobalOptions {
+    sourceName: string;
+    endpoint: string;
+    timeout: number;
+    operationHeaders: Record<string, string>;
+    queryStringOptions: IStringifyOptions;
+    queryParams: Record<string, string | number | boolean>;
+}
+export declare function addHTTPRootFieldResolver(schema: GraphQLSchema, field: GraphQLField<any, any>, logger: Logger, globalFetch: MeshFetch, { path, operationSpecificHeaders, httpMethod, isBinary, requestBaseBody, queryParamArgMap, queryStringOptionsByParam, }: HTTPRootFieldResolverOpts, { sourceName, endpoint, timeout, operationHeaders: globalOperationHeaders, queryStringOptions: globalQueryStringOptions, queryParams: globalQueryParams, }: GlobalOptions): void;

package/typings/bundle.d.cts

@@ -0,0 +1,34 @@
+import { GraphQLSchema } from 'graphql';
+import { JSONSchemaObject } from 'json-machete';
+import type { IStringifyOptions } from 'qs';
+import { Logger, MeshFetch } from '@graphql-mesh/types';
+import { JSONSchemaOperationConfig, OperationHeadersConfiguration } from './types.cjs';
+export interface JSONSchemaLoaderBundle {
+    name?: string;
+    endpoint?: string;
+    operations: JSONSchemaOperationConfig[];
+    operationHeaders?: Record<string, string>;
+    referencedSchema: JSONSchemaObject;
+}
+export interface JSONSchemaLoaderBundleOptions {
+    dereferencedSchema: JSONSchemaObject;
+    endpoint?: string;
+    operations: JSONSchemaOperationConfig[];
+    operationHeaders?: Record<string, string>;
+    logger?: Logger;
+}
+export declare function createBundleFromDereferencedSchema(name: string, { dereferencedSchema, endpoint, operations, operationHeaders, logger, }: JSONSchemaLoaderBundleOptions): Promise<JSONSchemaLoaderBundle>;
+export interface JSONSchemaLoaderBundleToGraphQLSchemaOptions {
+    cwd?: string;
+    logger?: Logger;
+    fetch?: MeshFetch;
+    endpoint?: string;
+    operationHeaders?: OperationHeadersConfiguration;
+    queryParams?: Record<string, string>;
+    queryStringOptions?: IStringifyOptions;
+}
+/**
+ * Generates a local GraphQLSchema instance from
+ * previously generated JSON Schema bundle
+ */
+export declare function getGraphQLSchemaFromBundle({ name, endpoint: bundledBaseUrl, operations, operationHeaders: bundledOperationHeaders, referencedSchema, }: JSONSchemaLoaderBundle, { cwd, logger, fetch, endpoint: overwrittenBaseUrl, operationHeaders: additionalOperationHeaders, queryParams, queryStringOptions, }?: JSONSchemaLoaderBundleToGraphQLSchemaOptions): Promise<GraphQLSchema>;

package/typings/bundle.d.ts

@@ -0,0 +1,34 @@
+import { GraphQLSchema } from 'graphql';
+import { JSONSchemaObject } from 'json-machete';
+import type { IStringifyOptions } from 'qs';
+import { Logger, MeshFetch } from '@graphql-mesh/types';
+import { JSONSchemaOperationConfig, OperationHeadersConfiguration } from './types.js';
+export interface JSONSchemaLoaderBundle {
+    name?: string;
+    endpoint?: string;
+    operations: JSONSchemaOperationConfig[];
+    operationHeaders?: Record<string, string>;
+    referencedSchema: JSONSchemaObject;
+}
+export interface JSONSchemaLoaderBundleOptions {
+    dereferencedSchema: JSONSchemaObject;
+    endpoint?: string;
+    operations: JSONSchemaOperationConfig[];
+    operationHeaders?: Record<string, string>;
+    logger?: Logger;
+}
+export declare function createBundleFromDereferencedSchema(name: string, { dereferencedSchema, endpoint, operations, operationHeaders, logger, }: JSONSchemaLoaderBundleOptions): Promise<JSONSchemaLoaderBundle>;
+export interface JSONSchemaLoaderBundleToGraphQLSchemaOptions {
+    cwd?: string;
+    logger?: Logger;
+    fetch?: MeshFetch;
+    endpoint?: string;
+    operationHeaders?: OperationHeadersConfiguration;
+    queryParams?: Record<string, string>;
+    queryStringOptions?: IStringifyOptions;
+}
+/**
+ * Generates a local GraphQLSchema instance from
+ * previously generated JSON Schema bundle
+ */
+export declare function getGraphQLSchemaFromBundle({ name, endpoint: bundledBaseUrl, operations, operationHeaders: bundledOperationHeaders, referencedSchema, }: JSONSchemaLoaderBundle, { cwd, logger, fetch, endpoint: overwrittenBaseUrl, operationHeaders: additionalOperationHeaders, queryParams, queryStringOptions, }?: JSONSchemaLoaderBundleToGraphQLSchemaOptions): Promise<GraphQLSchema>;

package/typings/directives.d.cts

@@ -0,0 +1,54 @@
+import { GraphQLDirective, GraphQLField, GraphQLInterfaceType, GraphQLLeafType, GraphQLScalarType, GraphQLSchema } from 'graphql';
+import { Logger, MeshFetch, MeshPubSub } from '@graphql-mesh/types';
+export declare const LengthDirective: GraphQLDirective;
+export declare function processLengthAnnotations(scalar: GraphQLScalarType, { min: minLength, max: maxLength, }: {
+    min?: number;
+    max?: number;
+}): void;
+export declare const DiscriminatorDirective: GraphQLDirective;
+export declare function processDiscriminatorAnnotations({ interfaceType, discriminatorFieldName, }: {
+    interfaceType: GraphQLInterfaceType;
+    discriminatorFieldName: string;
+}): void;
+export declare const ResolveRootDirective: GraphQLDirective;
+export declare function processResolveRootAnnotations(field: GraphQLField<any, any>): void;
+export declare const ResolveRootFieldDirective: GraphQLDirective;
+export declare function processResolveRootFieldAnnotations(field: GraphQLField<any, any>, propertyName: string): void;
+export declare const RegExpDirective: GraphQLDirective;
+export declare function processRegExpAnnotations(scalar: GraphQLScalarType, pattern: string): void;
+export declare const PubSubOperationDirective: GraphQLDirective;
+interface ProcessPubSubOperationAnnotationsOpts {
+    field: GraphQLField<any, any>;
+    globalPubsub: MeshPubSub;
+    pubsubTopic: string;
+    logger: Logger;
+}
+export declare function processPubSubOperationAnnotations({ field, globalPubsub, pubsubTopic, logger, }: ProcessPubSubOperationAnnotationsOpts): void;
+export declare const TypeScriptDirective: GraphQLDirective;
+export declare function processTypeScriptAnnotations(type: GraphQLLeafType, typeDefinition: string): void;
+export declare function processScalarType(schema: GraphQLSchema, type: GraphQLScalarType): void;
+export declare const HTTPOperationDirective: GraphQLDirective;
+export declare const GlobalOptionsDirective: GraphQLDirective;
+export declare const ResponseMetadataDirective: GraphQLDirective;
+export declare function processResponseMetadataAnnotations(field: GraphQLField<any, any>): void;
+export declare const LinkDirective: GraphQLDirective;
+export declare const LinkResolverDirective: GraphQLDirective;
+export declare function processLinkFieldAnnotations(field: GraphQLField<any, any>, defaultRootTypeName: string, defaultFieldName: string): void;
+export declare const DictionaryDirective: GraphQLDirective;
+export declare function processDictionaryDirective(fieldMap: Record<string, GraphQLField<any, any>>, field: GraphQLField<any, any>): void;
+interface ProcessDirectiveArgs {
+    schema: GraphQLSchema;
+    pubsub: MeshPubSub;
+    logger: Logger;
+    globalFetch: MeshFetch;
+    endpoint?: string;
+    timeout?: number;
+    operationHeaders?: Record<string, string>;
+    queryParams?: Record<string, any>;
+}
+export declare function processDirectives({ schema, globalFetch, logger, pubsub, ...extraGlobalOptions }: ProcessDirectiveArgs): GraphQLSchema;
+export declare const StatusCodeTypeNameDirective: GraphQLDirective;
+export declare const EnumDirective: GraphQLDirective;
+export declare const OneOfDirective: GraphQLDirective;
+export declare const ExampleDirective: GraphQLDirective;
+export {};

package/typings/directives.d.ts

@@ -0,0 +1,54 @@
+import { GraphQLDirective, GraphQLField, GraphQLInterfaceType, GraphQLLeafType, GraphQLScalarType, GraphQLSchema } from 'graphql';
+import { Logger, MeshFetch, MeshPubSub } from '@graphql-mesh/types';
+export declare const LengthDirective: GraphQLDirective;
+export declare function processLengthAnnotations(scalar: GraphQLScalarType, { min: minLength, max: maxLength, }: {
+    min?: number;
+    max?: number;
+}): void;
+export declare const DiscriminatorDirective: GraphQLDirective;
+export declare function processDiscriminatorAnnotations({ interfaceType, discriminatorFieldName, }: {
+    interfaceType: GraphQLInterfaceType;
+    discriminatorFieldName: string;
+}): void;
+export declare const ResolveRootDirective: GraphQLDirective;
+export declare function processResolveRootAnnotations(field: GraphQLField<any, any>): void;
+export declare const ResolveRootFieldDirective: GraphQLDirective;
+export declare function processResolveRootFieldAnnotations(field: GraphQLField<any, any>, propertyName: string): void;
+export declare const RegExpDirective: GraphQLDirective;
+export declare function processRegExpAnnotations(scalar: GraphQLScalarType, pattern: string): void;
+export declare const PubSubOperationDirective: GraphQLDirective;
+interface ProcessPubSubOperationAnnotationsOpts {
+    field: GraphQLField<any, any>;
+    globalPubsub: MeshPubSub;
+    pubsubTopic: string;
+    logger: Logger;
+}
+export declare function processPubSubOperationAnnotations({ field, globalPubsub, pubsubTopic, logger, }: ProcessPubSubOperationAnnotationsOpts): void;
+export declare const TypeScriptDirective: GraphQLDirective;
+export declare function processTypeScriptAnnotations(type: GraphQLLeafType, typeDefinition: string): void;
+export declare function processScalarType(schema: GraphQLSchema, type: GraphQLScalarType): void;
+export declare const HTTPOperationDirective: GraphQLDirective;
+export declare const GlobalOptionsDirective: GraphQLDirective;
+export declare const ResponseMetadataDirective: GraphQLDirective;
+export declare function processResponseMetadataAnnotations(field: GraphQLField<any, any>): void;
+export declare const LinkDirective: GraphQLDirective;
+export declare const LinkResolverDirective: GraphQLDirective;
+export declare function processLinkFieldAnnotations(field: GraphQLField<any, any>, defaultRootTypeName: string, defaultFieldName: string): void;
+export declare const DictionaryDirective: GraphQLDirective;
+export declare function processDictionaryDirective(fieldMap: Record<string, GraphQLField<any, any>>, field: GraphQLField<any, any>): void;
+interface ProcessDirectiveArgs {
+    schema: GraphQLSchema;
+    pubsub: MeshPubSub;
+    logger: Logger;
+    globalFetch: MeshFetch;
+    endpoint?: string;
+    timeout?: number;
+    operationHeaders?: Record<string, string>;
+    queryParams?: Record<string, any>;
+}
+export declare function processDirectives({ schema, globalFetch, logger, pubsub, ...extraGlobalOptions }: ProcessDirectiveArgs): GraphQLSchema;
+export declare const StatusCodeTypeNameDirective: GraphQLDirective;
+export declare const EnumDirective: GraphQLDirective;
+export declare const OneOfDirective: GraphQLDirective;
+export declare const ExampleDirective: GraphQLDirective;
+export {};

package/typings/getComposerFromJSONSchema.d.cts

@@ -0,0 +1,13 @@
+import { AnyTypeComposer, SchemaComposer } from 'graphql-compose';
+import { JSONSchema } from 'json-machete';
+import { Logger } from '@graphql-mesh/types';
+export interface TypeComposers {
+    input?: AnyTypeComposer<any>;
+    output: AnyTypeComposer<any> | SchemaComposer;
+    description?: string;
+    nullable?: boolean;
+    default?: any;
+    readOnly?: boolean;
+    writeOnly?: boolean;
+}
+export declare function getComposerFromJSONSchema(schema: JSONSchema, logger: Logger): Promise<TypeComposers>;

package/{getComposerFromJSONSchema.d.ts → typings/getComposerFromJSONSchema.d.ts}

@@ -1,10 +1,13 @@
 import { AnyTypeComposer, SchemaComposer } from 'graphql-compose';
-import { Logger } from '@graphql-mesh/types';
 import { JSONSchema } from 'json-machete';
-interface TypeComposers {
+import { Logger } from '@graphql-mesh/types';
+export interface TypeComposers {
     input?: AnyTypeComposer<any>;
     output: AnyTypeComposer<any> | SchemaComposer;
     description?: string;
+    nullable?: boolean;
+    default?: any;
+    readOnly?: boolean;
+    writeOnly?: boolean;
 }
-export declare function getComposerFromJSONSchema(schema: JSONSchema, logger: Logger, generateInterfaceFromSharedFields?: boolean): Promise<TypeComposers>;
-export {};
+export declare function getComposerFromJSONSchema(schema: JSONSchema, logger: Logger): Promise<TypeComposers>;

package/typings/getDereferencedJSONSchemaFromOperations.d.cts

@@ -0,0 +1,14 @@
+import { JSONSchemaObject } from 'json-machete';
+import { Logger } from '@graphql-mesh/types';
+import { JSONSchemaOperationConfig } from './types.cjs';
+export declare function getDereferencedJSONSchemaFromOperations({ operations, cwd, logger, fetchFn, schemaHeaders, ignoreErrorResponses, endpoint, operationHeaders, queryParams, }: {
+    operations: JSONSchemaOperationConfig[];
+    cwd: string;
+    logger: Logger;
+    fetchFn: WindowOrWorkerGlobalScope['fetch'];
+    schemaHeaders?: Record<string, string>;
+    ignoreErrorResponses?: boolean;
+    endpoint: string;
+    operationHeaders: Record<string, string>;
+    queryParams: Record<string, string | number | boolean>;
+}): Promise<JSONSchemaObject>;

package/{getDereferencedJSONSchemaFromOperations.d.ts → typings/getDereferencedJSONSchemaFromOperations.d.ts}

@@ -1,12 +1,14 @@
-import { JSONSchemaOperationConfig } from './types';
 import { JSONSchemaObject } from 'json-machete';
 import { Logger } from '@graphql-mesh/types';
-export declare function getDereferencedJSONSchemaFromOperations({ operations, cwd, logger, fetchFn, schemaHeaders, ignoreErrorResponses, noDeduplication, }: {
+import { JSONSchemaOperationConfig } from './types.js';
+export declare function getDereferencedJSONSchemaFromOperations({ operations, cwd, logger, fetchFn, schemaHeaders, ignoreErrorResponses, endpoint, operationHeaders, queryParams, }: {
     operations: JSONSchemaOperationConfig[];
     cwd: string;
     logger: Logger;
     fetchFn: WindowOrWorkerGlobalScope['fetch'];
     schemaHeaders?: Record<string, string>;
     ignoreErrorResponses?: boolean;
-    noDeduplication?: boolean;
+    endpoint: string;
+    operationHeaders: Record<string, string>;
+    queryParams: Record<string, string | number | boolean>;
 }): Promise<JSONSchemaObject>;

package/typings/getGraphQLSchemaFromDereferencedJSONSchema.d.cts

@@ -0,0 +1,5 @@
+import { JSONSchemaObject } from 'json-machete';
+import { AddExecutionLogicToComposerOptions } from './addExecutionLogicToComposer.cjs';
+export declare function getGraphQLSchemaFromDereferencedJSONSchema(name: string, opts: Omit<AddExecutionLogicToComposerOptions, 'schemaComposer'> & {
+    fullyDeferencedSchema: JSONSchemaObject;
+}): Promise<import("graphql").GraphQLSchema>;

package/typings/getGraphQLSchemaFromDereferencedJSONSchema.d.ts

@@ -0,0 +1,5 @@
+import { JSONSchemaObject } from 'json-machete';
+import { AddExecutionLogicToComposerOptions } from './addExecutionLogicToComposer.js';
+export declare function getGraphQLSchemaFromDereferencedJSONSchema(name: string, opts: Omit<AddExecutionLogicToComposerOptions, 'schemaComposer'> & {
+    fullyDeferencedSchema: JSONSchemaObject;
+}): Promise<import("graphql").GraphQLSchema>;

package/typings/getJSONSchemaStringFormatScalarMap.d.cts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare function getJSONSchemaStringFormatScalarMap(): Map<string, GraphQLScalarType>;

package/typings/getJSONSchemaStringFormatScalarMap.d.ts

@@ -0,0 +1,2 @@
+import { GraphQLScalarType } from 'graphql';
+export declare function getJSONSchemaStringFormatScalarMap(): Map<string, GraphQLScalarType>;

package/typings/getReferencedJSONSchemaFromOperations.d.cts

@@ -0,0 +1,16 @@
+import { JSONSchemaObject } from 'json-machete';
+import { Logger } from '@graphql-mesh/types';
+import { JSONSchemaOperationConfig } from './types.cjs';
+export declare function getReferencedJSONSchemaFromOperations({ operations, cwd, schemaHeaders, ignoreErrorResponses, logger, fetchFn, endpoint, operationHeaders, queryParams, }: {
+    operations: JSONSchemaOperationConfig[];
+    cwd: string;
+    schemaHeaders?: {
+        [key: string]: string;
+    };
+    ignoreErrorResponses?: boolean;
+    logger?: Logger;
+    fetchFn: WindowOrWorkerGlobalScope['fetch'];
+    endpoint: string;
+    operationHeaders: Record<string, string>;
+    queryParams: Record<string, string | number | boolean>;
+}): Promise<JSONSchemaObject>;

package/{getReferencedJSONSchemaFromOperations.d.ts → typings/getReferencedJSONSchemaFromOperations.d.ts}

@@ -1,8 +1,7 @@
-import { Logger } from '@graphql-mesh/types';
 import { JSONSchemaObject } from 'json-machete';
-import { JSONSchemaOperationConfig } from './types';
-export declare const anySchema: JSONSchemaObject;
-export declare function getReferencedJSONSchemaFromOperations({ operations, cwd, schemaHeaders, ignoreErrorResponses, logger, fetchFn, }: {
+import { Logger } from '@graphql-mesh/types';
+import { JSONSchemaOperationConfig } from './types.js';
+export declare function getReferencedJSONSchemaFromOperations({ operations, cwd, schemaHeaders, ignoreErrorResponses, logger, fetchFn, endpoint, operationHeaders, queryParams, }: {
     operations: JSONSchemaOperationConfig[];
     cwd: string;
     schemaHeaders?: {
@@ -11,4 +10,7 @@ export declare function getReferencedJSONSchemaFromOperations({ operations, cwd,
     ignoreErrorResponses?: boolean;
     logger?: Logger;
     fetchFn: WindowOrWorkerGlobalScope['fetch'];
+    endpoint: string;
+    operationHeaders: Record<string, string>;
+    queryParams: Record<string, string | number | boolean>;
 }): Promise<JSONSchemaObject>;

package/typings/getTypeResolverFromOutputTCs.d.cts

@@ -0,0 +1,7 @@
+import { GraphQLObjectType, GraphQLTypeResolver } from 'graphql';
+export declare function getTypeResolverFromOutputTCs({ possibleTypes, discriminatorField, discriminatorMapping, statusCodeTypeNameMap, }: {
+    possibleTypes: readonly GraphQLObjectType[];
+    discriminatorField?: string;
+    discriminatorMapping?: Record<string, string>;
+    statusCodeTypeNameMap?: Record<string, string>;
+}): GraphQLTypeResolver<any, any>;

package/typings/getTypeResolverFromOutputTCs.d.ts

@@ -0,0 +1,7 @@
+import { GraphQLObjectType, GraphQLTypeResolver } from 'graphql';
+export declare function getTypeResolverFromOutputTCs({ possibleTypes, discriminatorField, discriminatorMapping, statusCodeTypeNameMap, }: {
+    possibleTypes: readonly GraphQLObjectType[];
+    discriminatorField?: string;
+    discriminatorMapping?: Record<string, string>;
+    statusCodeTypeNameMap?: Record<string, string>;
+}): GraphQLTypeResolver<any, any>;

package/typings/getUnionTypeComposers.d.cts

@@ -0,0 +1,24 @@
+import { AnyTypeComposer, ComposeInputType, InputTypeComposer, ObjectTypeComposer, SchemaComposer, UnionTypeComposer } from 'graphql-compose';
+import { Logger } from '@graphql-mesh/types';
+import { JSONSchemaObject } from '@json-schema-tools/meta-schema';
+import { TypeComposers } from './getComposerFromJSONSchema.cjs';
+export interface GetUnionTypeComposersOpts {
+    schemaComposer: SchemaComposer;
+    typeComposersList: {
+        input?: AnyTypeComposer<any>;
+        output?: ObjectTypeComposer | UnionTypeComposer;
+    }[];
+    subSchemaAndTypeComposers: JSONSchemaObject & TypeComposers;
+    logger: Logger;
+}
+export declare function getContainerTC(schemaComposer: SchemaComposer, output: ComposeInputType): ObjectTypeComposer<any, any>;
+export declare function getUnionTypeComposers({ schemaComposer, typeComposersList, subSchemaAndTypeComposers, logger, }: GetUnionTypeComposersOpts): {
+    input?: AnyTypeComposer<any>;
+    output?: ObjectTypeComposer<any, any> | UnionTypeComposer<any, any>;
+} | {
+    input: InputTypeComposer<any>;
+    output: UnionTypeComposer<any, any>;
+    nullable: boolean;
+    readOnly: boolean;
+    writeOnly: boolean;
+};

package/typings/getUnionTypeComposers.d.ts

@@ -0,0 +1,24 @@
+import { AnyTypeComposer, ComposeInputType, InputTypeComposer, ObjectTypeComposer, SchemaComposer, UnionTypeComposer } from 'graphql-compose';
+import { Logger } from '@graphql-mesh/types';
+import { JSONSchemaObject } from '@json-schema-tools/meta-schema';
+import { TypeComposers } from './getComposerFromJSONSchema.js';
+export interface GetUnionTypeComposersOpts {
+    schemaComposer: SchemaComposer;
+    typeComposersList: {
+        input?: AnyTypeComposer<any>;
+        output?: ObjectTypeComposer | UnionTypeComposer;
+    }[];
+    subSchemaAndTypeComposers: JSONSchemaObject & TypeComposers;
+    logger: Logger;
+}
+export declare function getContainerTC(schemaComposer: SchemaComposer, output: ComposeInputType): ObjectTypeComposer<any, any>;
+export declare function getUnionTypeComposers({ schemaComposer, typeComposersList, subSchemaAndTypeComposers, logger, }: GetUnionTypeComposersOpts): {
+    input?: AnyTypeComposer<any>;
+    output?: ObjectTypeComposer<any, any> | UnionTypeComposer<any, any>;
+} | {
+    input: InputTypeComposer<any>;
+    output: UnionTypeComposer<any, any>;
+    nullable: boolean;
+    readOnly: boolean;
+    writeOnly: boolean;
+};

package/{getStringScalarWithMinMaxLength.d.ts → typings/getValidTypeName.d.cts}

@@ -1,6 +1,7 @@
-import { JSONSchemaObject } from '@json-schema-tools/meta-schema';
 import { SchemaComposer } from 'graphql-compose';
-export declare function getStringScalarWithMinMaxLength({ schemaComposer, subSchema, }: {
+import { JSONSchemaObject } from '@json-schema-tools/meta-schema';
+export declare function getValidTypeName({ schemaComposer, isInput, subSchema, }: {
     schemaComposer: SchemaComposer;
+    isInput: boolean;
     subSchema: JSONSchemaObject;
-}): import("graphql-compose").ScalarTypeComposer<any>;
+}): string;

package/typings/index.d.cts

@@ -0,0 +1,9 @@
+import { loadGraphQLSchemaFromJSONSchemas } from './loadGraphQLSchemaFromJSONSchemas.cjs';
+export default loadGraphQLSchemaFromJSONSchemas;
+export * from './loadGraphQLSchemaFromJSONSchemas.cjs';
+export * from './getComposerFromJSONSchema.cjs';
+export * from './getDereferencedJSONSchemaFromOperations.cjs';
+export * from './getGraphQLSchemaFromDereferencedJSONSchema.cjs';
+export * from './types.cjs';
+export { processDirectives } from './directives.cjs';
+export * from './bundle.cjs';

package/typings/index.d.ts

@@ -0,0 +1,9 @@
+import { loadGraphQLSchemaFromJSONSchemas } from './loadGraphQLSchemaFromJSONSchemas.js';
+export default loadGraphQLSchemaFromJSONSchemas;
+export * from './loadGraphQLSchemaFromJSONSchemas.js';
+export * from './getComposerFromJSONSchema.js';
+export * from './getDereferencedJSONSchemaFromOperations.js';
+export * from './getGraphQLSchemaFromDereferencedJSONSchema.js';
+export * from './types.js';
+export { processDirectives } from './directives.js';
+export * from './bundle.js';