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

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