@vertikalx/vtx-backend-client 1.0.0-dev.2 → 1.0.0-dev.21

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.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../libs/vtx-backend-client/runtime/index.ts"],"names":[],"mappings":";;;AACA,+CAA6C;AAApC,4GAAA,YAAY,OAAA;AAGrB,uEAAqE;AAA5D,oIAAA,wBAAwB,OAAA;AAEjC,6CAA2C;AAAlC,0GAAA,WAAW,OAAA;AAEpB,qCAAyC;AAAhC,wGAAA,aAAa,OAAA;AACtB,iCAAoC;AAA3B,mGAAA,UAAU,OAAA;AACN,QAAA,UAAU,GAAG;IACtB,QAAQ,EAAE,IAAI;CACjB,CAAA"}

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,
-}

package/runtime/linkTypeMap.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"linkTypeMap.js","sourceRoot":"","sources":["../../../../libs/vtx-backend-client/runtime/linkTypeMap.ts"],"names":[],"mappings":"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"}

package/runtime/linkTypeMap.ts

@@ -1,156 +0,0 @@
-// @ts-nocheck
-import type {
-    CompressedType,
-    CompressedTypeMap,
-    LinkedArgMap,
-    LinkedField,
-    LinkedType,
-    LinkedTypeMap,
-} from './types'
-
-export interface PartialLinkedFieldMap {
-    [field: string]: {
-        type: string
-        args?: LinkedArgMap
-    }
-}
-
-export const linkTypeMap = (
-    typeMap: CompressedTypeMap<number>,
-): LinkedTypeMap => {
-    const indexToName: Record<number, string> = Object.assign(
-        {},
-        ...Object.keys(typeMap.types).map((k, i) => ({ [i]: k })),
-    )
-
-    let intermediaryTypeMap = Object.assign(
-        {},
-        ...Object.keys(typeMap.types || {}).map(
-            (k): Record<string, LinkedType> => {
-                const type: CompressedType = typeMap.types[k]!
-                const fields = type || {}
-                return {
-                    [k]: {
-                        name: k,
-                        // type scalar properties
-                        scalar: Object.keys(fields).filter((f) => {
-                            const [type] = fields[f] || []
-
-                            const isScalar =
-                                type && typeMap.scalars.includes(type)
-                            if (!isScalar) {
-                                return false
-                            }
-                            const args = fields[f]?.[1]
-                            const argTypes = Object.values(args || {})
-                                .map((x) => x?.[1])
-                                .filter(Boolean)
-
-                            const hasRequiredArgs = argTypes.some(
-                                (str) => str && str.endsWith('!'),
-                            )
-                            if (hasRequiredArgs) {
-                                return false
-                            }
-                            return true
-                        }),
-                        // fields with corresponding `type` and `args`
-                        fields: Object.assign(
-                            {},
-                            ...Object.keys(fields).map(
-                                (f): PartialLinkedFieldMap => {
-                                    const [typeIndex, args] = fields[f] || []
-                                    if (typeIndex == null) {
-                                        return {}
-                                    }
-                                    return {
-                                        [f]: {
-                                            // replace index with type name
-                                            type: indexToName[typeIndex],
-                                            args: Object.assign(
-                                                {},
-                                                ...Object.keys(args || {}).map(
-                                                    (k) => {
-                                                        // if argTypeString == argTypeName, argTypeString is missing, need to readd it
-                                                        if (!args || !args[k]) {
-                                                            return
-                                                        }
-                                                        const [
-                                                            argTypeName,
-                                                            argTypeString,
-                                                        ] = args[k] as any
-                                                        return {
-                                                            [k]: [
-                                                                indexToName[
-                                                                    argTypeName
-                                                                ],
-                                                                argTypeString ||
-                                                                    indexToName[
-                                                                        argTypeName
-                                                                    ],
-                                                            ],
-                                                        }
-                                                    },
-                                                ),
-                                            ),
-                                        },
-                                    }
-                                },
-                            ),
-                        ),
-                    },
-                }
-            },
-        ),
-    )
-    const res = resolveConcreteTypes(intermediaryTypeMap)
-    return res
-}
-
-// replace typename with concrete type
-export const resolveConcreteTypes = (linkedTypeMap: LinkedTypeMap) => {
-    Object.keys(linkedTypeMap).forEach((typeNameFromKey) => {
-        const type: LinkedType = linkedTypeMap[typeNameFromKey]!
-        // type.name = typeNameFromKey
-        if (!type.fields) {
-            return
-        }
-
-        const fields = type.fields
-
-        Object.keys(fields).forEach((f) => {
-            const field: LinkedField = fields[f]!
-
-            if (field.args) {
-                const args = field.args
-                Object.keys(args).forEach((key) => {
-                    const arg = args[key]
-
-                    if (arg) {
-                        const [typeName] = arg
-
-                        if (typeof typeName === 'string') {
-                            if (!linkedTypeMap[typeName]) {
-                                linkedTypeMap[typeName] = { name: typeName }
-                            }
-
-                            arg[0] = linkedTypeMap[typeName]!
-                        }
-                    }
-                })
-            }
-
-            const typeName = field.type as LinkedType | string
-
-            if (typeof typeName === 'string') {
-                if (!linkedTypeMap[typeName]) {
-                    linkedTypeMap[typeName] = { name: typeName }
-                }
-
-                field.type = linkedTypeMap[typeName]!
-            }
-        })
-    })
-
-    return linkedTypeMap
-}

package/runtime/typeSelection.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"typeSelection.js","sourceRoot":"","sources":["../../../../libs/vtx-backend-client/runtime/typeSelection.ts"],"names":[],"mappings":""}

package/runtime/typeSelection.ts

@@ -1,95 +0,0 @@
-// @ts-nocheck
-//////////////////////////////////////////////////
-
-// SOME THINGS TO KNOW BEFORE DIVING IN
-/*
-0. DST is the request type, SRC is the response type
-
-1. FieldsSelection uses an object because currently is impossible to make recursive types
-
-2. FieldsSelection is a recursive type that makes a type based on request type and fields
-
-3. HandleObject handles object types
-
-4. Handle__scalar adds all scalar properties excluding non scalar props
-*/
-
-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<
-          {
-              // using keyof SRC to maintain ?: relations of SRC type
-              [Key in keyof SRC]: Key extends keyof DST
-                  ? FieldsSelection<SRC[Key], NonNullable<DST[Key]>>
-                  : SRC[Key]
-          },
-          Exclude<keyof DST, FieldsToRemove>
-          //   {
-          //       // remove falsy values
-          //       [Key in keyof DST]: DST[Key] extends false | 0 ? never : Key
-          //   }[keyof DST]
-      >
-
-type Handle__scalar<SRC extends Anify<DST>, DST> = SRC extends Nil
-    ? never
-    : Pick<
-          // continue processing fields that are in DST, directly pass SRC type if not in DST
-          {
-              [Key in keyof SRC]: Key extends keyof DST
-                  ? FieldsSelection<SRC[Key], DST[Key]>
-                  : SRC[Key]
-          },
-          // remove fields that are not scalars or are not in DST
-          {
-              [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> // just return the union type
-
-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

package/runtime/types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../libs/vtx-backend-client/runtime/types.ts"],"names":[],"mappings":""}

package/runtime/types.ts

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