types-package

const gql = _String_.raw;

type ParamsType<SRC> = SRC extends [infer Params, infer Result] ? Params : { [K in keyof SRC]: ParamsType<SRC[K]> };

query{ stuff here }

typeof GetType<X>

createQuery((vars, q) => q({user: [{id: vars.id}, {name: true}]}))

import { sdk } from './generated'

const UserQuery = sdk.query({
  name: "UserById",
  variables: {
    userId: "ID!"
  },
  selection: {
    user: {
      [sdk.arguments]: {
        byId: "userId"
      },
      id: true,
      login: true,
    },
  },
});

[sdk.arguments]

import { builder } from "./builder"

import "./types/auth"
import "./types/business"
import "./types/workspace"
import "./types/user"
import "./types/session"
import "./types/customer"

export const schema = builder.toSchema({})

builder.ts

import SchemaBuilder from "@pothos/core"
import { Context } from "@bumi/core/context"
import { JSONResolver, DateResolver, LocalDateResolver } from "graphql-scalars"
import RelayPlugin from "@pothos/plugin-relay"
import { decodeTime } from "ulid"
import { VisibleError } from "@bumi/core/errors"

export const builder = new SchemaBuilder<{
  Context: Context
  Scalars: {
    ID: {
      Input: string
      Output: string
    }
    Date: {
      Input: Date
      Output: string
    }
    LocalDate: {
      Input: string
      Output: string
    }
    JSON: {
      Input: string
      Output: string
    }
  }
}>({
  plugins: [RelayPlugin],
  relayOptions: {},
})
builder.scalarType("ID", {
  serialize: (x) => x,
  parseValue: (x) => {
    if (typeof x !== "string" || !decodeTime(x))
      throw new VisibleError(`Invalid ULID: ${x}`)
    return x
  },
})
builder.addScalarType("JSON", JSONResolver, {})
builder.addScalarType("Date", DateResolver, {})
builder.addScalarType("LocalDate", LocalDateResolver, {})

builder.queryType({})
builder.mutationType({})

import { builder } from "../builder"
import { Workspace } from "@bumi/core/workspace"
import { WorkspaceType } from "./workspace"

import { User } from "@bumi/core/user"

export const UserType = builder
  .objectRef<User.UserEntityType>("User")
  .implement({
    fields: (t) => ({
      id: t.exposeID("userID"),
      email: t.exposeString("email"),
      workspace: t.field({
        type: WorkspaceType,
        resolve: (user) => Workspace.fromID(user.workspaceID),
      }),
    }),
  })

const q = tq({
  cardById: [
    {
      cardId: $$('test'),
    },
    {
      Attack: true,
      Defense: true,
    },
  ],
});

const q: TypedDocumentNode<{
    cardById?: {
        Attack: number;
        Defense: number;
    } | undefined;
}, {
    test: string | null | undefined;
}>

and

or