@vertikalx/vtx-backend-client 1.0.0-dev-daniel.0 → 1.0.0-dev-daniel.1

package/runtime/batcher.ts

@@ -1,275 +0,0 @@
-// @ts-nocheck
-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/runtime/createClient.ts

@@ -1,68 +0,0 @@
-// @ts-nocheck
-
-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/runtime/error.ts

@@ -1,29 +0,0 @@
-// @ts-nocheck
-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/runtime/fetcher.ts

@@ -1,97 +0,0 @@
-// @ts-nocheck
-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/runtime/generateGraphqlOperation.ts

@@ -1,225 +0,0 @@
-// @ts-nocheck
-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/runtime/index.ts

@@ -1,13 +0,0 @@
-// @ts-nocheck
-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,
-}