@tomsd/github-repo-js 0.3.0 → 0.4.0

package/dist/generated/github/index.d.ts

@@ -0,0 +1,25 @@
+import type { QueryGenqlSelection, Query, MutationGenqlSelection, Mutation } from './schema';
+import { type FieldsSelection, type GraphqlOperation, type ClientOptions, GenqlError } from './runtime';
+export type { FieldsSelection } from './runtime';
+export { GenqlError };
+export * from './schema';
+export interface Client {
+    query<R extends QueryGenqlSelection>(request: R & {
+        __name?: string;
+    }): Promise<FieldsSelection<Query, R>>;
+    mutation<R extends MutationGenqlSelection>(request: R & {
+        __name?: string;
+    }): Promise<FieldsSelection<Mutation, R>>;
+}
+export declare const createClient: (options?: ClientOptions) => Client;
+export declare const everything: {
+    __scalar: boolean;
+};
+export type QueryResult<fields extends QueryGenqlSelection> = FieldsSelection<Query, fields>;
+export declare const generateQueryOp: (fields: QueryGenqlSelection & {
+    __name?: string;
+}) => GraphqlOperation;
+export type MutationResult<fields extends MutationGenqlSelection> = FieldsSelection<Mutation, fields>;
+export declare const generateMutationOp: (fields: MutationGenqlSelection & {
+    __name?: string;
+}) => GraphqlOperation;

package/dist/generated/github/runtime/batcher.d.ts

@@ -0,0 +1,105 @@
+import type { GraphqlOperation } from './generateGraphqlOperation';
+type Variables = Record<string, any>;
+type QueryError = Error & {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: any;
+    rid: string;
+    details?: Record<string, any>;
+};
+type Result = {
+    data: Record<string, any>;
+    errors: Array<QueryError>;
+};
+type Fetcher = (batchedQuery: GraphqlOperation | Array<GraphqlOperation>) => Promise<Array<Result>>;
+type Options = {
+    batchInterval?: number;
+    shouldBatch?: boolean;
+    maxBatchSize?: number;
+};
+type Queue = Array<{
+    request: GraphqlOperation;
+    resolve: (...args: Array<any>) => any;
+    reject: (...args: Array<any>) => any;
+}>;
+/**
+ * Create a batcher client.
+ * @param {Fetcher} fetcher                 - A function that can handle the network requests to graphql endpoint
+ * @param {Options} options                 - the options to be used by client
+ * @param {boolean} options.shouldBatch     - should the client batch requests. (default true)
+ * @param {integer} options.batchInterval   - duration (in MS) of each batch window. (default 6)
+ * @param {integer} options.maxBatchSize    - max number of requests in a batch. (default 0)
+ * @param {boolean} options.defaultHeaders  - default headers to include with every request
+ *
+ * @example
+ * const fetcher = batchedQuery => fetch('path/to/graphql', {
+ *    method: 'post',
+ *    headers: {
+ *      Accept: 'application/json',
+ *      'Content-Type': 'application/json',
+ *    },
+ *    body: JSON.stringify(batchedQuery),
+ *    credentials: 'include',
+ * })
+ * .then(response => response.json())
+ *
+ * const client = new QueryBatcher(fetcher, { maxBatchSize: 10 })
+ */
+export declare class QueryBatcher {
+    fetcher: Fetcher;
+    _options: Options;
+    _queue: Queue;
+    constructor(fetcher: Fetcher, { batchInterval, shouldBatch, maxBatchSize, }?: Options);
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {promise} resolves to parsed json of server response
+     *
+     * @example
+     * client.fetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    fetch(query: string, variables?: Variables, operationName?: string, overrides?: Options): Promise<Result>;
+    /**
+     * Fetch will send a graphql request and return the parsed json.
+     * @param {string}      query          - the graphql query.
+     * @param {Variables}   variables      - any variables you wish to inject as key/value pairs.
+     * @param {[string]}    operationName  - the graphql operationName.
+     * @param {Options}     overrides      - the client options overrides.
+     *
+     * @return {Promise<Array<Result>>} resolves to parsed json of server response
+     *
+     * @example
+     * client.forceFetch(`
+     *    query getHuman($id: ID!) {
+     *      human(id: $id) {
+     *        name
+     *        height
+     *      }
+     *    }
+     * `, { id: "1001" }, 'getHuman')
+     *    .then(human => {
+     *      // do something with human
+     *      console.log(human);
+     *    });
+     */
+    forceFetch(query: string, variables?: Variables, operationName?: string, overrides?: Options): Promise<Result>;
+}
+export {};

package/dist/generated/github/runtime/createClient.d.ts

@@ -0,0 +1,17 @@
+import { type BatchOptions } from './fetcher';
+import type { ExecutionResult, LinkedType } from './types';
+import { type GraphqlOperation } from './generateGraphqlOperation';
+export type Headers = HeadersInit | (() => HeadersInit) | (() => Promise<HeadersInit>);
+export type BaseFetcher = (operation: GraphqlOperation | GraphqlOperation[]) => Promise<ExecutionResult | ExecutionResult[]>;
+export type ClientOptions = Omit<RequestInit, 'body' | 'headers'> & {
+    url?: string;
+    batch?: BatchOptions | boolean;
+    fetcher?: BaseFetcher;
+    fetch?: Function;
+    headers?: Headers;
+};
+export declare const createClient: ({ queryRoot, mutationRoot, subscriptionRoot, ...options }: ClientOptions & {
+    queryRoot?: LinkedType;
+    mutationRoot?: LinkedType;
+    subscriptionRoot?: LinkedType;
+}) => any;

package/dist/generated/github/runtime/error.d.ts

@@ -0,0 +1,18 @@
+export declare class GenqlError extends Error {
+    errors: Array<GraphqlError>;
+    /**
+     * Partial data returned by the server
+     */
+    data?: any;
+    constructor(errors: any[], data: any);
+}
+interface GraphqlError {
+    message: string;
+    locations?: Array<{
+        line: number;
+        column: number;
+    }>;
+    path?: string[];
+    extensions?: Record<string, any>;
+}
+export {};

package/dist/generated/github/runtime/fetcher.d.ts

@@ -0,0 +1,10 @@
+import type { ClientOptions } from './createClient';
+import type { GraphqlOperation } from './generateGraphqlOperation';
+export interface Fetcher {
+    (gql: GraphqlOperation): Promise<any>;
+}
+export type BatchOptions = {
+    batchInterval?: number;
+    maxBatchSize?: number;
+};
+export declare const createFetcher: ({ url, headers, fetcher, fetch: _fetch, batch, ...rest }: ClientOptions) => Fetcher;

package/dist/generated/github/runtime/generateGraphqlOperation.d.ts

@@ -0,0 +1,30 @@
+import type { LinkedField, LinkedType } from './types';
+export interface Args {
+    [arg: string]: any | undefined;
+}
+export interface Fields {
+    [field: string]: Request;
+}
+export type Request = boolean | number | Fields;
+export interface Variables {
+    [name: string]: {
+        value: any;
+        typing: [LinkedType, string];
+    };
+}
+export interface Context {
+    root: LinkedType;
+    varCounter: number;
+    variables: Variables;
+    fragmentCounter: number;
+    fragments: string[];
+}
+export interface GraphqlOperation {
+    query: string;
+    variables?: {
+        [name: string]: any;
+    };
+    operationName?: string;
+}
+export declare const generateGraphqlOperation: (operation: "query" | "mutation" | "subscription", root: LinkedType, fields?: Fields) => GraphqlOperation;
+export declare const getFieldFromPath: (root: LinkedType | undefined, path: string[]) => LinkedField;

package/dist/generated/github/runtime/index.d.ts

@@ -0,0 +1,11 @@
+export { createClient } from './createClient';
+export type { ClientOptions } from './createClient';
+export type { FieldsSelection } from './typeSelection';
+export { generateGraphqlOperation } from './generateGraphqlOperation';
+export type { GraphqlOperation } from './generateGraphqlOperation';
+export { linkTypeMap } from './linkTypeMap';
+export { createFetcher } from './fetcher';
+export { GenqlError } from './error';
+export declare const everything: {
+    __scalar: boolean;
+};

package/dist/generated/github/runtime/linkTypeMap.d.ts

@@ -0,0 +1,9 @@
+import type { CompressedTypeMap, LinkedArgMap, LinkedTypeMap } from './types';
+export interface PartialLinkedFieldMap {
+    [field: string]: {
+        type: string;
+        args?: LinkedArgMap;
+    };
+}
+export declare const linkTypeMap: (typeMap: CompressedTypeMap<number>) => LinkedTypeMap;
+export declare const resolveConcreteTypes: (linkedTypeMap: LinkedTypeMap) => LinkedTypeMap;

package/dist/generated/github/runtime/typeSelection.d.ts

@@ -0,0 +1,28 @@
+export type FieldsSelection<SRC extends Anify<DST> | undefined, DST> = {
+    scalar: SRC;
+    union: Handle__isUnion<SRC, DST>;
+    object: HandleObject<SRC, DST>;
+    array: SRC extends Nil ? never : SRC extends Array<infer T | null> ? Array<FieldsSelection<T, DST>> : never;
+    __scalar: Handle__scalar<SRC, DST>;
+    never: never;
+}[DST extends Nil ? 'never' : DST extends false | 0 ? 'never' : SRC extends Scalar ? 'scalar' : SRC extends any[] ? 'array' : SRC extends {
+    __isUnion?: any;
+} ? 'union' : DST extends {
+    __scalar?: any;
+} ? '__scalar' : DST extends {} ? 'object' : 'never'];
+type HandleObject<SRC extends Anify<DST>, DST> = DST extends boolean ? SRC : SRC extends Nil ? never : Pick<{
+    [Key in keyof SRC]: Key extends keyof DST ? FieldsSelection<SRC[Key], NonNullable<DST[Key]>> : SRC[Key];
+}, Exclude<keyof DST, FieldsToRemove>>;
+type Handle__scalar<SRC extends Anify<DST>, DST> = SRC extends Nil ? never : Pick<{
+    [Key in keyof SRC]: Key extends keyof DST ? FieldsSelection<SRC[Key], DST[Key]> : SRC[Key];
+}, {
+    [Key in keyof SRC]: SRC[Key] extends Nil ? never : Key extends FieldsToRemove ? never : SRC[Key] extends Scalar ? Key : Key extends keyof DST ? Key : never;
+}[keyof SRC]>;
+type Handle__isUnion<SRC extends Anify<DST>, DST> = SRC extends Nil ? never : Omit<SRC, FieldsToRemove>;
+type Scalar = string | number | Date | boolean | null | undefined;
+type Anify<T> = {
+    [P in keyof T]?: any;
+};
+type FieldsToRemove = '__isUnion' | '__scalar' | '__name' | '__args';
+type Nil = undefined | null;
+export {};

package/dist/generated/github/runtime/types.d.ts

@@ -0,0 +1,55 @@
+export interface ExecutionResult<TData = {
+    [key: string]: any;
+}> {
+    errors?: Array<Error>;
+    data?: TData | null;
+}
+export interface ArgMap<keyType = number> {
+    [arg: string]: [keyType, string] | [keyType] | undefined;
+}
+export type CompressedField<keyType = number> = [
+    type: keyType,
+    args?: ArgMap<keyType>
+];
+export interface CompressedFieldMap<keyType = number> {
+    [field: string]: CompressedField<keyType> | undefined;
+}
+export type CompressedType<keyType = number> = CompressedFieldMap<keyType>;
+export interface CompressedTypeMap<keyType = number> {
+    scalars: Array<keyType>;
+    types: {
+        [type: string]: CompressedType<keyType> | undefined;
+    };
+}
+export type Field<keyType = number> = {
+    type: keyType;
+    args?: ArgMap<keyType>;
+};
+export interface FieldMap<keyType = number> {
+    [field: string]: Field<keyType> | undefined;
+}
+export type Type<keyType = number> = FieldMap<keyType>;
+export interface TypeMap<keyType = number> {
+    scalars: Array<keyType>;
+    types: {
+        [type: string]: Type<keyType> | undefined;
+    };
+}
+export interface LinkedArgMap {
+    [arg: string]: [LinkedType, string] | undefined;
+}
+export interface LinkedField {
+    type: LinkedType;
+    args?: LinkedArgMap;
+}
+export interface LinkedFieldMap {
+    [field: string]: LinkedField | undefined;
+}
+export interface LinkedType {
+    name: string;
+    fields?: LinkedFieldMap;
+    scalar?: string[];
+}
+export interface LinkedTypeMap {
+    [type: string]: LinkedType | undefined;
+}