#@soda-gql/core

import { defineScalar } from "@soda-gql/core";

export const scalar = {
  // Simple syntax
  ...defineScalar<"ID", string, string>("ID"),
  ...defineScalar<"String", string, string>("String"),

  // Callback syntax with directives
  ...defineScalar("DateTime", ({ type }) => ({
    input: type<string>(),
    output: type<Date>(),
    directives: {},
  })),
} as const;

import { gql } from "@/graphql-system";

// Fragment
gql.default(({ fragment }) =>
  fragment("UserFields", "User")`{ id name email }`()
);

// Query
gql.default(({ query }) =>
  query("GetUser")`($id: ID!) { user(id: $id) { id name } }`()
);

// Mutation
gql.default(({ mutation }) =>
  mutation("CreateUser")`($input: CreateUserInput!) { createUser(input: $input) { id } }`()
);

// Subscription
gql.default(({ subscription }) =>
  subscription("OnUserCreated")`{ userCreated { id name } }`()
);

import { gql } from "@/graphql-system";

// Fragment (tagged template)
gql.default(({ fragment }) =>
  fragment("UserFields", "User")`{ id name }`(),
);

// Query (options-object path — useful for $dir, aliases, programmatic field control)
gql.default(({ query }) =>
  query("GetUser")({ variables: `($id: ID!)`, fields: ({ f, $ }) => ({ ... }) })({}),
);

// Mutation (options-object path)
gql.default(({ mutation }) =>
  mutation("CreateUser")({ variables: `($input: CreateUserInput!)`, fields: ({ f, $ }) => ({ ... }) })({}),
);

import type { GqlElementAttachment } from "@soda-gql/core";

export const userFragment = gql
  .default(({ fragment }) =>
    fragment("UserFields", "User")`{ id name }`(),
  )
  .attach({
    name: "utils",
    createValue: (element) => ({
      getDisplayName: (user: typeof element.$infer.output) =>
        user.name.toUpperCase(),
    }),
  });

// Usage
userFragment.utils.getDisplayName(userData);

interface GqlElementAttachment<TElement, TName extends string, TValue> {
  name: TName;
  createValue: (element: TElement) => TValue;
}

const fragment = gql
  .default(...)
  .attach(attachment1)
  .attach(attachment2);

// Access both
fragment.attachment1Name;
fragment.attachment2Name;

gql.default(({ query }) =>
  query("GetUser")`($id: ID!) { user(id: $id) { id name } }`({
    metadata: ({ $, document, $var }) => ({
      headers: { "X-Request-ID": "get-user" },
      custom: { requiresAuth: true, hash: hashDocument(document) },
    }),
  }),
);

const meta = operation.metadata({ id: "123" });
console.log(meta.headers);
console.log(meta.custom);

$var.getName($.userId)  // Returns "userId"

// When $.status was assigned a literal value like "active"
$var.getValue($.status)  // Returns "active"

$var.getInner($.userId)
// Returns { type: "variable", name: "userId" }

// Given a variable defined with an input type containing nested VarRefs
// e.g., a variable declared as ($filter: UserFilter!) where UserFilter has { userId: $.id }
$var.getNameAt($.filter, p => p.userId)  // Returns "id"

// Given a variable declared as ($categoryId: String_comparison_exp)
// When called with { _eq: "tech", _neq: "spam" }
$var.getValueAt($.categoryId, p => p._eq)   // Returns "tech"
$var.getValueAt($.categoryId, p => p._neq)  // Returns "spam"

query("GetUser")`($id: ID!) { user(id: $id) { id name } }`()

query("GetUser")({ variables: `($id: ID!)`, fields: ({ f, $ }) => ({ ... }) })({})

query("CreateUser")`($input: CreateUserInput!) { createUser(input: $input) { id } }`()
query("Search")`($filters: [FilterInput!]) { search(filters: $filters) { id } }`()

// Fragment types
type UserInput = typeof userFragment.$infer.input;
type UserOutput = typeof userFragment.$infer.output;

// Operation types
type QueryVariables = typeof query.$infer.input;
type QueryResult = typeof query.$infer.output.projected;

// Metadata type
type QueryMeta = typeof query.$infer.metadata;

import { gqlRuntime } from "@soda-gql/core/runtime";

// Get registered operation
const operation = gqlRuntime.getOperation("canonicalId");

import { defineAdapter } from "@soda-gql/core/adapter";

const adapter = defineAdapter({
  helpers: {
    auth: {
      requiresLogin: () => ({ requiresAuth: true }),
    },
  },
  metadata: {
    aggregateFragmentMetadata: (fragments) => ({
      count: fragments.length,
    }),
    schemaLevel: { apiVersion: "v2" },
  },
  transformDocument: ({ document, operationType }) => {
    // Modify document AST
    return document;
  },
});

type Adapter<THelpers, TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel> = {
  helpers?: THelpers;
  metadata?: MetadataAdapter<TFragmentMetadata, TAggregatedFragmentMetadata, TSchemaLevel>;
  transformDocument?: DocumentTransformer<TSchemaLevel, TAggregatedFragmentMetadata>;
};

gql.default(({ query }) =>
  query("GetUser")`($id: ID!) { user(id: $id) { id name } }`({
    metadata: () => ({ cacheHint: 300 }),
    transformDocument: ({ document, metadata }) => {
      // metadata is typed as { cacheHint: number }
      return document;
    },
  }),
);