@manot40/genql-cli 1.0.0

package/dist/runtime/batcher.ts

@@ -0,0 +1,256 @@
+import type { GraphqlOperation } from './generateGraphqlOperation';
+import { GenqlError } from './error';
+
+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;
+}>;
+
+/**
+ * takes a list of requests (queue) and batches them into a single server request.
+ * It will then resolve each individual requests promise with the appropriate data.
+ * @private
+ * @param {QueryBatcher}   client - the client to use
+ * @param {Queue} queue  - the list of requests to batch
+ */
+function dispatchQueueBatch(client: QueryBatcher, queue: Queue): void {
+  let batchedQuery: any = queue.map((item) => item.request);
+
+  if (batchedQuery.length === 1) {
+    batchedQuery = batchedQuery[0];
+  }
+  (() => {
+    try {
+      return client.fetcher(batchedQuery);
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  })()
+    .then((responses: any) => {
+      if (queue.length === 1 && !Array.isArray(responses)) {
+        if (responses.errors && responses.errors.length) {
+          queue[0].reject(new GenqlError(responses.errors, responses.data));
+          return;
+        }
+
+        queue[0].resolve(responses);
+        return;
+      } else if (responses.length !== queue.length) {
+        throw new Error('response length did not match query length');
+      }
+
+      for (let i = 0; i < queue.length; i++) {
+        if (responses[i].errors && responses[i].errors.length) {
+          queue[i].reject(new GenqlError(responses[i].errors, responses[i].data));
+        } else {
+          queue[i].resolve(responses[i]);
+        }
+      }
+    })
+    .catch((e) => {
+      for (let i = 0; i < queue.length; i++) {
+        queue[i].reject(e);
+      }
+    });
+}
+
+/**
+ * creates a list of requests to batch according to max batch size.
+ * @private
+ * @param {QueryBatcher} client - the client to create list of requests from from
+ * @param {Options} options - the options for the batch
+ */
+function dispatchQueue(client: QueryBatcher, options: Options): void {
+  const queue = client._queue;
+  const maxBatchSize = options.maxBatchSize || 0;
+  client._queue = [];
+
+  if (maxBatchSize > 0 && maxBatchSize < queue.length) {
+    for (let i = 0; i < queue.length / maxBatchSize; i++) {
+      dispatchQueueBatch(client, queue.slice(i * maxBatchSize, (i + 1) * maxBatchSize));
+    }
+  } else {
+    dispatchQueueBatch(client, queue);
+  }
+}
+/**
+ * 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 class QueryBatcher {
+  fetcher: Fetcher;
+  _options: Options;
+  _queue: Queue;
+
+  constructor(fetcher: Fetcher, { batchInterval = 6, shouldBatch = true, maxBatchSize = 0 }: Options = {}) {
+    this.fetcher = fetcher;
+    this._options = {
+      batchInterval,
+      shouldBatch,
+      maxBatchSize,
+    };
+    this._queue = [];
+  }
+
+  /**
+   * 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> {
+    const request: GraphqlOperation = {
+      query,
+    };
+    const options = Object.assign({}, this._options, overrides);
+
+    if (variables) {
+      request.variables = variables;
+    }
+
+    if (operationName) {
+      request.operationName = operationName;
+    }
+
+    const promise = new Promise<Result>((resolve, reject) => {
+      this._queue.push({
+        request,
+        resolve,
+        reject,
+      });
+
+      if (this._queue.length === 1) {
+        if (options.shouldBatch) {
+          setTimeout(() => dispatchQueue(this, options), options.batchInterval);
+        } else {
+          dispatchQueue(this, options);
+        }
+      }
+    });
+    return promise;
+  }
+
+  /**
+   * 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> {
+    const request: GraphqlOperation = {
+      query,
+    };
+    const options = Object.assign({}, this._options, overrides, {
+      shouldBatch: false,
+    });
+
+    if (variables) {
+      request.variables = variables;
+    }
+
+    if (operationName) {
+      request.operationName = operationName;
+    }
+
+    const promise = new Promise<Result>((resolve, reject) => {
+      const client = new QueryBatcher(this.fetcher, this._options);
+      client._queue = [
+        {
+          request,
+          resolve,
+          reject,
+        },
+      ];
+      dispatchQueue(client, options);
+    });
+    return promise;
+  }
+}

package/dist/runtime/createClient.ts

@@ -0,0 +1,55 @@
+import { type BatchOptions, createFetcher } from './fetcher';
+import type { ExecutionResult, LinkedType } from './types';
+import { generateGraphqlOperation, 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 const createClient = ({
+  queryRoot,
+  mutationRoot,
+  subscriptionRoot,
+  ...options
+}: ClientOptions & {
+  queryRoot?: LinkedType;
+  mutationRoot?: LinkedType;
+  subscriptionRoot?: LinkedType;
+}) => {
+  const fetcher = createFetcher(options);
+  const client: {
+    query?: Function;
+    mutation?: Function;
+  } = {};
+
+  if (queryRoot) {
+    client.query = (request: any) => {
+      if (!queryRoot) throw new Error('queryRoot argument is missing');
+
+      const resultPromise = fetcher(generateGraphqlOperation('query', queryRoot, request));
+
+      return resultPromise;
+    };
+  }
+  if (mutationRoot) {
+    client.mutation = (request: any) => {
+      if (!mutationRoot) throw new Error('mutationRoot argument is missing');
+
+      const resultPromise = fetcher(generateGraphqlOperation('mutation', mutationRoot, request));
+
+      return resultPromise;
+    };
+  }
+
+  return client as any;
+};

package/dist/runtime/error.ts

@@ -0,0 +1,26 @@
+export class GenqlError extends Error {
+  errors: Array<GraphqlError> = [];
+  /**
+   * Partial data returned by the server
+   */
+  data?: any;
+  constructor(errors: any[], data: any) {
+    let message = Array.isArray(errors) ? errors.map((x) => x?.message || '').join('\n') : '';
+    if (!message) {
+      message = 'GraphQL error';
+    }
+    super(message);
+    this.errors = errors;
+    this.data = data;
+  }
+}
+
+interface GraphqlError {
+  message: string;
+  locations?: Array<{
+    line: number;
+    column: number;
+  }>;
+  path?: string[];
+  extensions?: Record<string, any>;
+}

package/dist/runtime/fetcher.ts

@@ -0,0 +1,95 @@
+import { QueryBatcher } from './batcher';
+
+import type { ClientOptions } from './createClient';
+import type { GraphqlOperation } from './generateGraphqlOperation';
+import { GenqlError } from './error';
+
+export interface Fetcher {
+  (gql: GraphqlOperation): Promise<any>;
+}
+
+export type BatchOptions = {
+  batchInterval?: number; // ms
+  maxBatchSize?: number;
+};
+
+const DEFAULT_BATCH_OPTIONS = {
+  maxBatchSize: 10,
+  batchInterval: 40,
+};
+
+export const createFetcher = ({
+  url,
+  headers = {},
+  fetcher,
+  fetch: _fetch,
+  batch = false,
+  ...rest
+}: ClientOptions): Fetcher => {
+  if (!url && !fetcher) {
+    throw new Error('url or fetcher is required');
+  }
+
+  fetcher =
+    fetcher ||
+    (async (body) => {
+      let headersObject = typeof headers == 'function' ? await headers() : headers;
+      headersObject = headersObject || {};
+      if (typeof fetch === 'undefined' && !_fetch) {
+        throw new Error(
+          'Global `fetch` function is not available, pass a fetch polyfill to Genql `createClient`'
+        );
+      }
+      let fetchImpl = _fetch || fetch;
+      const res = await fetchImpl(url!, {
+        headers: {
+          'Content-Type': 'application/json',
+          ...headersObject,
+        },
+        method: 'POST',
+        body: JSON.stringify(body),
+        ...rest,
+      });
+      if (!res.ok) {
+        throw new Error(`${res.statusText}: ${await res.text()}`);
+      }
+      const json = await res.json();
+      return json;
+    });
+
+  if (!batch) {
+    return async (body) => {
+      const json = await fetcher!(body);
+      if (Array.isArray(json)) {
+        return json.map((json) => {
+          if (json?.errors?.length) {
+            throw new GenqlError(json.errors || [], json.data);
+          }
+          return json.data;
+        });
+      } else {
+        if (json?.errors?.length) {
+          throw new GenqlError(json.errors || [], json.data);
+        }
+        return json.data;
+      }
+    };
+  }
+
+  const batcher = new QueryBatcher(
+    async (batchedQuery) => {
+      // console.log(batchedQuery) // [{ query: 'query{user{age}}', variables: {} }, ...]
+      const json = await fetcher!(batchedQuery);
+      return json as any;
+    },
+    batch === true ? DEFAULT_BATCH_OPTIONS : batch
+  );
+
+  return async ({ query, variables }) => {
+    const json = await batcher.fetch(query, variables);
+    if (json?.data) {
+      return json.data;
+    }
+    throw new Error('Genql batch fetcher returned unexpected result ' + JSON.stringify(json));
+  };
+};

package/dist/runtime/generateGraphqlOperation.ts

@@ -0,0 +1,193 @@
+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;
+}
+
+const parseRequest = (request: Request | undefined, ctx: Context, path: string[]): string => {
+  if (typeof request === 'object' && '__args' in request) {
+    const args: any = request.__args;
+    let fields: Request | undefined = { ...request };
+    delete fields.__args;
+    const argNames = Object.keys(args);
+
+    if (argNames.length === 0) {
+      return parseRequest(fields, ctx, path);
+    }
+
+    const field = getFieldFromPath(ctx.root, path);
+
+    const argStrings = argNames.map((argName) => {
+      ctx.varCounter++;
+      const varName = `v${ctx.varCounter}`;
+
+      const typing = field.args && field.args[argName]; // typeMap used here, .args
+
+      if (!typing) {
+        throw new Error(`no typing defined for argument \`${argName}\` in path \`${path.join('.')}\``);
+      }
+
+      ctx.variables[varName] = {
+        value: args[argName],
+        typing,
+      };
+
+      return `${argName}:$${varName}`;
+    });
+    return `(${argStrings})${parseRequest(fields, ctx, path)}`;
+  } else if (typeof request === 'object' && Object.keys(request).length > 0) {
+    const fields = request;
+    const fieldNames = Object.keys(fields).filter((k) => Boolean(fields[k]));
+
+    if (fieldNames.length === 0) {
+      throw new Error(`field selection should not be empty: ${path.join('.')}`);
+    }
+
+    const type = path.length > 0 ? getFieldFromPath(ctx.root, path).type : ctx.root;
+    const scalarFields = type.scalar;
+
+    let scalarFieldsFragment: string | undefined;
+
+    if (fieldNames.includes('__scalar')) {
+      const falsyFieldNames = new Set(Object.keys(fields).filter((k) => !Boolean(fields[k])));
+      if (scalarFields?.length) {
+        ctx.fragmentCounter++;
+        scalarFieldsFragment = `f${ctx.fragmentCounter}`;
+
+        ctx.fragments.push(
+          `fragment ${scalarFieldsFragment} on ${type.name}{${scalarFields
+            .filter((f) => !falsyFieldNames.has(f))
+            .join(',')}}`
+        );
+      }
+    }
+
+    const fieldsSelection = fieldNames
+      .filter((f) => !['__scalar', '__name'].includes(f))
+      .map((f) => {
+        const parsed = parseRequest(fields[f], ctx, [...path, f]);
+
+        if (f.startsWith('on_')) {
+          ctx.fragmentCounter++;
+          const implementationFragment = `f${ctx.fragmentCounter}`;
+
+          const typeMatch = f.match(/^on_(.+)/);
+
+          if (!typeMatch || !typeMatch[1]) throw new Error('match failed');
+
+          ctx.fragments.push(`fragment ${implementationFragment} on ${typeMatch[1]}${parsed}`);
+
+          return `...${implementationFragment}`;
+        } else {
+          return `${f}${parsed}`;
+        }
+      })
+      .concat(scalarFieldsFragment ? [`...${scalarFieldsFragment}`] : [])
+      .join(',');
+
+    return `{${fieldsSelection}}`;
+  } else {
+    return '';
+  }
+};
+
+export const generateGraphqlOperation = (
+  operation: 'query' | 'mutation' | 'subscription',
+  root: LinkedType,
+  fields?: Fields
+): GraphqlOperation => {
+  const ctx: Context = {
+    root: root,
+    varCounter: 0,
+    variables: {},
+    fragmentCounter: 0,
+    fragments: [],
+  };
+  const result = parseRequest(fields, ctx, []);
+
+  const varNames = Object.keys(ctx.variables);
+
+  const varsString =
+    varNames.length > 0
+      ? `(${varNames.map((v) => {
+          const variableType = ctx.variables[v].typing[1];
+          return `$${v}:${variableType}`;
+        })})`
+      : '';
+
+  const operationName = fields?.__name || '';
+
+  return {
+    query: [`${operation} ${operationName}${varsString}${result}`, ...ctx.fragments].join(','),
+    variables: Object.keys(ctx.variables).reduce<{ [name: string]: any }>((r, v) => {
+      r[v] = ctx.variables[v].value;
+      return r;
+    }, {}),
+    ...(operationName ? { operationName: operationName.toString() } : {}),
+  };
+};
+
+export const getFieldFromPath = (root: LinkedType | undefined, path: string[]) => {
+  let current: LinkedField | undefined;
+
+  if (!root) throw new Error('root type is not provided');
+
+  if (path.length === 0) throw new Error(`path is empty`);
+
+  path.forEach((f) => {
+    const type = current ? current.type : root;
+
+    if (!type.fields) throw new Error(`type \`${type.name}\` does not have fields`);
+
+    const possibleTypes = Object.keys(type.fields)
+      .filter((i) => i.startsWith('on_'))
+      .reduce(
+        (types, fieldName) => {
+          const field = type.fields && type.fields[fieldName];
+          if (field) types.push(field.type);
+          return types;
+        },
+        [type]
+      );
+
+    let field: LinkedField | null = null;
+
+    possibleTypes.forEach((type) => {
+      const found = type.fields && type.fields[f];
+      if (found) field = found;
+    });
+
+    if (!field) throw new Error(`type \`${type.name}\` does not have a field \`${f}\``);
+
+    current = field;
+  });
+
+  return current as LinkedField;
+};

package/dist/runtime/index.ts

@@ -0,0 +1,12 @@
+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 { Observable } from 'zen-observable-ts'
+export { createFetcher } from './fetcher';
+export { GenqlError } from './error';
+export const everything = {
+  __scalar: true,
+};