@vertikalx/vtx-backend-client 3.0.1-dev-max.1 → 3.0.1-dev-max.2

package/src/api/vtx-mobile-api.ts

@@ -1,43 +0,0 @@
-
-import pjson from "../../package.json";
-import { ValidatedToken } from "../client";
-import { APICallHeaders, DEFAULT_APP_KEY_HEADER, DEFAULT_HEADERS, DEFAULT_SYSTEM_USER_TOKEN_HEADER } from "./api-call-headers";
-import { ITypedBackendResponse } from "./backend-response";
-import { buildErrorResponse, buildResponse } from "./response-builder";
-import { VTXBaseAPI } from "./vtx-base-api";
-
-
-
-
-
-export class VTXMobileAPI extends VTXBaseAPI{
-
-    constructor(backendUrl:string, userToken?:string, requestConfig?: { fetch?: typeof fetch }){
-        super(backendUrl, VTXMobileAPI.getDefaultHeaders(userToken), requestConfig);
-    }
-
-    public static getDefaultHeaders(userToken?:string):APICallHeaders{
-
-        if (userToken){
-            return {
-                //[DEFAULT_APP_KEY_HEADER]: mobileAppKey,
-                [DEFAULT_SYSTEM_USER_TOKEN_HEADER]: userToken,
-                ...DEFAULT_HEADERS
-            }
-        }else{
-            return {
-                //[DEFAULT_APP_KEY_HEADER]: mobileAppKey,
-                ...DEFAULT_HEADERS
-            }
-        }
-    }
-
-    public async getMobileToken(token: string): Promise<ITypedBackendResponse<ValidatedToken>> {
-        return this.execute<ValidatedToken>(
-            () => this.sdk.ValidateToken({ input: token }),
-            'validateToken',
-            (r: any) => !!r?.validateToken?.accessToken,
-            'validateToken'
-        );
-    }
-}

package/src/api/vtx-web-browser-api.ts

@@ -1,46 +0,0 @@
-
-import pjson from "../../package.json";
-import { APICallHeaders, DEFAULT_APP_KEY_HEADER, DEFAULT_HEADERS, DEFAULT_SYSTEM_USER_TOKEN_HEADER } from "./api-call-headers";
-import { VTXBaseAPI } from "./vtx-base-api";
-
-
-
-
-
-export class VTXWebBrowserAPI extends VTXBaseAPI{
-
-    constructor(backendUrl:string, userToken?:string  ){
-        super(backendUrl, VTXWebBrowserAPI.getDefaultHeaders(userToken));
-
-    }
-
-    public setUserToken(userToken:string|null){
-        if (userToken){
-            this.headers = {
-                ...this.headers,
-                [DEFAULT_SYSTEM_USER_TOKEN_HEADER]: userToken,
-            }
-        }else{
-            delete this.headers[DEFAULT_SYSTEM_USER_TOKEN_HEADER];
-        }
-        this.gqlClient.setHeaders(this.headers as Record<string, string>);
-    }
-
-    public static getDefaultHeaders(userToken?:string):APICallHeaders{
-        
-        if (userToken){
-            return {                            
-                ...DEFAULT_HEADERS,
-                [DEFAULT_SYSTEM_USER_TOKEN_HEADER]: userToken,
-            }    
-    
-        }else{
-            return {            
-                ...DEFAULT_HEADERS
-            }    
-    
-        }
-        
-    }
-
-}

package/src/api/vtx-web-server-api.ts

@@ -1,41 +0,0 @@
-
-import pjson from "../../package.json";
-import { APICallHeaders, DEFAULT_APP_KEY_HEADER, DEFAULT_HEADERS, DEFAULT_SYSTEM_KEY_NAME_HEADER, DEFAULT_SYSTEM_KEY_VALUE_HEADER, DEFAULT_SYSTEM_USER_TOKEN_HEADER } from "./api-call-headers";
-import { VTXBaseAPI } from "./vtx-base-api";
-
-
-
-
-
-export class VTXWebServerAPI extends VTXBaseAPI{
-
-    constructor(backendUrl:string, systemKeyName:string, systemKeyValue:string){
-        super(backendUrl, VTXWebServerAPI.getDefaultHeaders(systemKeyName, systemKeyValue));        
-
-        if (VTXBaseAPI.isBrowser()){
-            throw new Error('VTXWebServerAPI should NOT be used in Browser');
-        }
-    }
-    public setUserToken(userToken:string|null){
-        if (userToken){
-            this.headers = {
-                [DEFAULT_SYSTEM_USER_TOKEN_HEADER]: userToken,
-                ...this.headers
-            }
-        }else{
-            delete this.headers[DEFAULT_SYSTEM_USER_TOKEN_HEADER];
-        }
-        this.gqlClient.setHeaders(this.headers as Record<string, string>);
-    }
-
-    public static getDefaultHeaders(systemKeyName:string, systemKeyValue:string):APICallHeaders{
-        
-        return {            
-            [DEFAULT_SYSTEM_KEY_NAME_HEADER]: systemKeyName,
-            [DEFAULT_SYSTEM_KEY_VALUE_HEADER]: systemKeyValue,
-            ...DEFAULT_HEADERS
-        }    
-        
-    }
-
-}

package/src/client/index.ts

@@ -1,65 +0,0 @@
-// @ts-nocheck
-import type {
-  QueryGenqlSelection,
-  Query,
-  MutationGenqlSelection,
-  Mutation,
-} from './schema'
-import {
-  linkTypeMap,
-  createClient as createClientOriginal,
-  generateGraphqlOperation,
-  type FieldsSelection,
-  type GraphqlOperation,
-  type ClientOptions,
-  GenqlError,
-} from './runtime'
-export type { FieldsSelection } from './runtime'
-export { GenqlError }
-
-import types from './types'
-export * from './schema'
-const typeMap = linkTypeMap(types as any)
-
-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 const createClient = function (options?: ClientOptions): Client {
-  return createClientOriginal({
-    url: undefined,
-
-    ...options,
-    queryRoot: typeMap.Query!,
-    mutationRoot: typeMap.Mutation!,
-    subscriptionRoot: typeMap.Subscription!,
-  }) as any
-}
-
-export const everything = {
-  __scalar: true,
-}
-
-export type QueryResult<fields extends QueryGenqlSelection> = FieldsSelection<
-  Query,
-  fields
->
-export const generateQueryOp: (
-  fields: QueryGenqlSelection & { __name?: string },
-) => GraphqlOperation = function (fields) {
-  return generateGraphqlOperation('query', typeMap.Query!, fields as any)
-}
-
-export type MutationResult<fields extends MutationGenqlSelection> =
-  FieldsSelection<Mutation, fields>
-export const generateMutationOp: (
-  fields: MutationGenqlSelection & { __name?: string },
-) => GraphqlOperation = function (fields) {
-  return generateGraphqlOperation('mutation', typeMap.Mutation!, fields as any)
-}

package/src/client/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/src/client/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/src/client/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/src/client/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),
-        )
-    }
-}