@effect-gql/federation 0.1.0 → 1.1.0

package/src/pipe-api.ts

@@ -1,263 +0,0 @@
-import { Effect } from "effect"
-import * as S from "effect/Schema"
-import type { DirectiveApplication } from "@effect-gql/core"
-import { FederatedSchemaBuilder } from "./federated-builder"
-import type { EntityRegistration } from "./types"
-
-// ============================================================================
-// Entity Registration
-// ============================================================================
-
-/**
- * Register an entity type with @key directive(s) and reference resolver.
- *
- * @example
- * ```typescript
- * FederatedSchemaBuilder.empty.pipe(
- *   entity({
- *     name: "User",
- *     schema: UserSchema,
- *     keys: [key({ fields: "id" })],
- *     resolveReference: (ref) => UserService.findById(ref.id),
- *   }),
- * )
- * ```
- */
-export const entity =
-  <A, R>(config: EntityRegistration<A, R>) =>
-  <R2>(builder: FederatedSchemaBuilder<R2>): FederatedSchemaBuilder<R | R2> =>
-    builder.entity(config)
-
-// ============================================================================
-// Query/Mutation/Subscription
-// ============================================================================
-
-/**
- * Add a query field
- */
-export const query =
-  <A, E, R, Args = void>(
-    name: string,
-    config: {
-      type: S.Schema<A, any, any>
-      args?: S.Schema<Args, any, any>
-      description?: string
-      directives?: readonly DirectiveApplication[]
-      resolve: (args: Args) => Effect.Effect<A, E, R>
-    }
-  ) =>
-  <R2>(builder: FederatedSchemaBuilder<R2>): FederatedSchemaBuilder<R | R2> =>
-    builder.query(name, config)
-
-/**
- * Add a mutation field
- */
-export const mutation =
-  <A, E, R, Args = void>(
-    name: string,
-    config: {
-      type: S.Schema<A, any, any>
-      args?: S.Schema<Args, any, any>
-      description?: string
-      directives?: readonly DirectiveApplication[]
-      resolve: (args: Args) => Effect.Effect<A, E, R>
-    }
-  ) =>
-  <R2>(builder: FederatedSchemaBuilder<R2>): FederatedSchemaBuilder<R | R2> =>
-    builder.mutation(name, config)
-
-/**
- * Add a subscription field
- */
-export const subscription =
-  <A, E, R, Args = void>(
-    name: string,
-    config: {
-      type: S.Schema<A, any, any>
-      args?: S.Schema<Args, any, any>
-      description?: string
-      directives?: readonly DirectiveApplication[]
-      subscribe: (args: Args) => Effect.Effect<import("effect").Stream.Stream<A, E, R>, E, R>
-      resolve?: (value: A, args: Args) => Effect.Effect<A, E, R>
-    }
-  ) =>
-  <R2>(builder: FederatedSchemaBuilder<R2>): FederatedSchemaBuilder<R | R2> =>
-    builder.subscription(name, config)
-
-// ============================================================================
-// Type Registration
-// ============================================================================
-
-/**
- * Register an object type (non-entity)
- */
-export const objectType =
-  <A>(config: {
-    name?: string
-    schema: S.Schema<A, any, any>
-    implements?: readonly string[]
-    directives?: readonly DirectiveApplication[]
-  }) =>
-  <R>(builder: FederatedSchemaBuilder<R>): FederatedSchemaBuilder<R> =>
-    builder.objectType(config)
-
-/**
- * Register an interface type
- */
-export const interfaceType =
-  (config: {
-    name?: string
-    schema: S.Schema<any, any, any>
-    resolveType?: (value: any) => string
-    directives?: readonly DirectiveApplication[]
-  }) =>
-  <R>(builder: FederatedSchemaBuilder<R>): FederatedSchemaBuilder<R> =>
-    builder.interfaceType(config)
-
-/**
- * Register an enum type
- */
-export const enumType =
-  (config: {
-    name: string
-    values: readonly string[]
-    description?: string
-    directives?: readonly DirectiveApplication[]
-  }) =>
-  <R>(builder: FederatedSchemaBuilder<R>): FederatedSchemaBuilder<R> =>
-    builder.enumType(config)
-
-/**
- * Register a union type
- */
-export const unionType =
-  (config: {
-    name: string
-    types: readonly string[]
-    resolveType?: (value: any) => string
-    directives?: readonly DirectiveApplication[]
-  }) =>
-  <R>(builder: FederatedSchemaBuilder<R>): FederatedSchemaBuilder<R> =>
-    builder.unionType(config)
-
-/**
- * Register an input type
- */
-export const inputType =
-  (config: {
-    name?: string
-    schema: S.Schema<any, any, any>
-    description?: string
-    directives?: readonly DirectiveApplication[]
-  }) =>
-  <R>(builder: FederatedSchemaBuilder<R>): FederatedSchemaBuilder<R> =>
-    builder.inputType(config)
-
-/**
- * Add a computed/relational field to an object type
- */
-export const field =
-  <Parent, A, E, R, Args = void>(
-    typeName: string,
-    fieldName: string,
-    config: {
-      type: S.Schema<A, any, any>
-      args?: S.Schema<Args, any, any>
-      description?: string
-      directives?: readonly DirectiveApplication[]
-      resolve: (parent: Parent, args: Args) => Effect.Effect<A, E, R>
-    }
-  ) =>
-  <R2>(builder: FederatedSchemaBuilder<R2>): FederatedSchemaBuilder<R | R2> =>
-    builder.field(typeName, fieldName, config)
-
-// ============================================================================
-// Field-Level Federation Directive Helpers
-// ============================================================================
-
-/**
- * Create a field configuration with @external directive
- */
-export const externalField = <A>(config: {
-  type: S.Schema<A, any, any>
-  description?: string
-}): {
-  type: S.Schema<A, any, any>
-  description?: string
-  directives: readonly DirectiveApplication[]
-  resolve: (parent: any) => Effect.Effect<A, never, never>
-} => ({
-  type: config.type,
-  description: config.description,
-  directives: [{ name: "external" }],
-  resolve: (parent: any) => Effect.succeed(parent),
-})
-
-/**
- * Create a field configuration with @requires directive
- */
-export const requiresField = <A, E, R, Parent = any>(config: {
-  type: S.Schema<A, any, any>
-  fields: string
-  description?: string
-  resolve: (parent: Parent) => Effect.Effect<A, E, R>
-}): {
-  type: S.Schema<A, any, any>
-  description?: string
-  directives: readonly DirectiveApplication[]
-  resolve: (parent: Parent) => Effect.Effect<A, E, R>
-} => ({
-  type: config.type,
-  description: config.description,
-  directives: [{ name: "requires", args: { fields: config.fields } }],
-  resolve: config.resolve,
-})
-
-/**
- * Create a field configuration with @provides directive
- */
-export const providesField = <A, E, R, Parent = any>(config: {
-  type: S.Schema<A, any, any>
-  fields: string
-  description?: string
-  resolve: (parent: Parent) => Effect.Effect<A, E, R>
-}): {
-  type: S.Schema<A, any, any>
-  description?: string
-  directives: readonly DirectiveApplication[]
-  resolve: (parent: Parent) => Effect.Effect<A, E, R>
-} => ({
-  type: config.type,
-  description: config.description,
-  directives: [{ name: "provides", args: { fields: config.fields } }],
-  resolve: config.resolve,
-})
-
-/**
- * Create a field configuration with @override directive
- */
-export const overrideField = <A, E, R, Parent = any>(config: {
-  type: S.Schema<A, any, any>
-  from: string
-  label?: string
-  description?: string
-  resolve: (parent: Parent) => Effect.Effect<A, E, R>
-}): {
-  type: S.Schema<A, any, any>
-  description?: string
-  directives: readonly DirectiveApplication[]
-  resolve: (parent: Parent) => Effect.Effect<A, E, R>
-} => ({
-  type: config.type,
-  description: config.description,
-  directives: [
-    {
-      name: "override",
-      args: {
-        from: config.from,
-        ...(config.label !== undefined ? { label: config.label } : {}),
-      },
-    },
-  ],
-  resolve: config.resolve,
-})

package/src/scalars.ts

@@ -1,59 +0,0 @@
-import { GraphQLScalarType, Kind, type ValueNode } from "@effect-gql/core"
-
-/**
- * Parse a literal value from the AST to a JavaScript value
- */
-function parseLiteralToValue(ast: ValueNode): unknown {
-  switch (ast.kind) {
-    case Kind.STRING:
-    case Kind.BOOLEAN:
-      return ast.value
-    case Kind.INT:
-      return parseInt(ast.value, 10)
-    case Kind.FLOAT:
-      return parseFloat(ast.value)
-    case Kind.NULL:
-      return null
-    case Kind.LIST:
-      return ast.values.map(parseLiteralToValue)
-    case Kind.OBJECT: {
-      const obj: Record<string, unknown> = {}
-      for (const field of ast.fields) {
-        obj[field.name.value] = parseLiteralToValue(field.value)
-      }
-      return obj
-    }
-    default:
-      return undefined
-  }
-}
-
-/**
- * The _Any scalar is used for entity representations in the _entities query.
- * It accepts any JSON value representing an entity with __typename and key fields.
- */
-export const AnyScalar = new GraphQLScalarType({
-  name: "_Any",
-  description:
-    "The _Any scalar is used to pass representations of entities from external services.",
-  serialize: (value) => value,
-  parseValue: (value) => value,
-  parseLiteral: parseLiteralToValue,
-})
-
-/**
- * The _FieldSet scalar represents a selection of fields.
- * It's used in directive arguments like @key(fields: "id") and @requires(fields: "weight").
- */
-export const FieldSetScalar = new GraphQLScalarType({
-  name: "_FieldSet",
-  description: "A string representing a selection of fields.",
-  serialize: (value) => value,
-  parseValue: (value) => value,
-  parseLiteral: (ast) => {
-    if (ast.kind === Kind.STRING) {
-      return ast.value
-    }
-    return undefined
-  },
-})

package/src/types.ts

@@ -1,114 +0,0 @@
-import { Effect } from "effect"
-import * as S from "effect/Schema"
-
-/**
- * Configuration for a @key directive
- */
-export interface KeyDirective {
-  /** FieldSet selection string (e.g., "id" or "sku package") */
-  readonly fields: string
-  /** Whether this key can be used to resolve the entity. Default: true */
-  readonly resolvable?: boolean
-}
-
-/**
- * All Federation 2.x directive types
- */
-export type FederationDirective =
-  | { readonly _tag: "key"; readonly fields: string; readonly resolvable?: boolean }
-  | { readonly _tag: "external" }
-  | { readonly _tag: "requires"; readonly fields: string }
-  | { readonly _tag: "provides"; readonly fields: string }
-  | { readonly _tag: "shareable" }
-  | { readonly _tag: "inaccessible" }
-  | { readonly _tag: "override"; readonly from: string; readonly label?: string }
-  | { readonly _tag: "interfaceObject" }
-  | { readonly _tag: "tag"; readonly name: string }
-
-/**
- * Entity representation sent to _entities query
- * Contains __typename plus the key fields
- */
-export interface EntityRepresentation {
-  readonly __typename: string
-  readonly [key: string]: unknown
-}
-
-/**
- * Configuration for registering an entity type
- */
-export interface EntityRegistration<A, R = never> {
-  /** Type name */
-  readonly name: string
-  /** Effect Schema for the entity type */
-  readonly schema: S.Schema<A, any, any>
-  /** Key directive configurations (at least one required) */
-  readonly keys: readonly KeyDirective[]
-  /** Additional directives to apply to the type */
-  readonly directives?: readonly FederationDirective[]
-  /**
-   * Reference resolver - given key fields, return the full entity.
-   * The representation contains __typename plus all fields from any matching @key.
-   */
-  readonly resolveReference: (
-    representation: Partial<A> & { __typename: string }
-  ) => Effect.Effect<A | null, any, R>
-}
-
-/**
- * Configuration for the FederatedSchemaBuilder
- */
-export interface FederatedSchemaConfig {
-  /** Federation specification version (default: "2.3") */
-  readonly version?: string
-}
-
-/**
- * Result of building a federated schema
- */
-export interface FederatedSchemaResult {
-  /** The GraphQL schema with Federation queries */
-  readonly schema: import("graphql").GraphQLSchema
-  /** The Federation-compliant SDL with directive annotations */
-  readonly sdl: string
-}
-
-/**
- * Convert a FederationDirective to a DirectiveApplication
- */
-export function toDirectiveApplication(
-  directive: FederationDirective
-): import("@effect-gql/core").DirectiveApplication {
-  switch (directive._tag) {
-    case "key":
-      return {
-        name: "key",
-        args: {
-          fields: directive.fields,
-          ...(directive.resolvable !== undefined ? { resolvable: directive.resolvable } : {}),
-        },
-      }
-    case "external":
-      return { name: "external" }
-    case "requires":
-      return { name: "requires", args: { fields: directive.fields } }
-    case "provides":
-      return { name: "provides", args: { fields: directive.fields } }
-    case "shareable":
-      return { name: "shareable" }
-    case "inaccessible":
-      return { name: "inaccessible" }
-    case "override":
-      return {
-        name: "override",
-        args: {
-          from: directive.from,
-          ...(directive.label !== undefined ? { label: directive.label } : {}),
-        },
-      }
-    case "interfaceObject":
-      return { name: "interfaceObject" }
-    case "tag":
-      return { name: "tag", args: { name: directive.name } }
-  }
-}