@baeta/extension-complexity 2.0.0-next.1 → 2.0.0-next.2

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # @baeta/extension-complexity
 
+## 2.0.0-next.2
+
+### Patch Changes
+
+- Fix broken types
+
+- Updated dependencies []:
+  - @baeta/core@2.0.0-next.2
+
 ## 2.0.0-next.1
 
 ### Patch Changes

package/dist/index.d.ts

@@ -0,0 +1,200 @@
+import { FieldBuilder, TypeBuilder, SubscriptionBuilder, Extension, ModuleCompiler } from '@baeta/core/sdk';
+import { GraphQLError, GraphQLErrorOptions } from 'graphql';
+
+/**
+ * Configuration for field complexity calculation.
+ */
+type FieldSettings = {
+    complexity?: number;
+    multiplier?: number;
+};
+/**
+ * Arguments passed to field settings functions.
+ */
+type GetFieldSettingsArgs<Context, Args> = {
+    /** Arguments passed to the GraphQL field */
+    args: Args;
+    /** Request context */
+    ctx: Context;
+};
+/**
+ * Function to determine complexity settings for a field.
+ * Returns either field settings or false to disable complexity calculation.
+ *
+ * @param params - Object containing field arguments and context
+ * @returns Field settings object or false
+ */
+type GetFieldSettings<Context, Args> = (params: GetFieldSettingsArgs<Context, Args>) => FieldSettings | false;
+
+/** biome-ignore-all lint/correctness/noUnusedVariables: arguments used for inference */
+
+declare global {
+    export namespace BaetaExtensions {
+        interface FieldExtensions<Result, Source, Context, Args, Info, Builder extends FieldBuilder<Result, Source, Context, Args, Info>> {
+            /**
+             * Configures complexity calculation for a type field.
+             *
+             * @param fn - Function to determine complexity settings
+             *
+             * @example
+             * ```typescript
+             * Query.users.$complexity((_, args) => ({
+             *   complexity: 1,
+             *   multiplier: args.limit || 10
+             * })).resolve(...);
+             *
+             * // Disable complexity calculation
+             * Query.simple.$complexity(() => false);
+             * ```
+             */
+            $complexity: (fn: GetFieldSettings<Context, Args>) => ReturnType<Builder['toMethods']>;
+        }
+        interface TypeExtensions<Source, Context, Info, Builder extends TypeBuilder<Source, Context, Info>> {
+            /**
+             * Configures complexity calculation for a type field.
+             *
+             * @param fn - Function to determine complexity settings
+             *
+             * @example
+             * ```typescript
+             * Query.users.$complexity((_, args) => ({
+             *   complexity: 1,
+             *   multiplier: args.limit || 10
+             * })).resolve(...);
+             *
+             * // Disable complexity calculation
+             * Query.simple.$complexity(() => false);
+             * ```
+             */
+            $complexity: (fn: GetFieldSettings<Context, unknown>) => ReturnType<Builder['toMethods']>;
+        }
+        interface SubscriptionExtensions<Result, Source, Context, Args, Info, Builder extends SubscriptionBuilder<Result, Source, Context, Args, Info>> {
+            /**
+             * Configures complexity calculation for a type field.
+             *
+             * @param fn - Function to determine complexity settings
+             *
+             * @example
+             * ```typescript
+             * Query.users.$complexity((_, args) => ({
+             *   complexity: 1,
+             *   multiplier: args.limit || 10
+             * })).resolve(...);
+             *
+             * // Disable complexity calculation
+             * Query.simple.$complexity(() => false);
+             * ```
+             */
+            $complexity: (fn: GetFieldSettings<Context, Args>) => ReturnType<Builder['toMethods']>;
+        }
+    }
+}
+
+/** Complexity error code */
+declare const ComplexityErrorCode = "COMPLEXITY_ERROR";
+/**
+ * Thrown when a query exceeds the complexity limits.
+ */
+declare class ComplexityError extends GraphQLError {
+    constructor(message?: string, options?: GraphQLErrorOptions);
+}
+/**
+ * Types of complexity validation errors that can occur during query analysis.
+ */
+declare const ComplexityErrorKind: {
+    /** Query exceeds maximum allowed depth */
+    Depth: string;
+    /** Query exceeds maximum allowed breadth (fields per level) */
+    Breadth: string;
+    /** Query exceeds total complexity score limit */
+    Complexity: string;
+};
+type ComplexityErrorKind = (typeof ComplexityErrorKind)[keyof typeof ComplexityErrorKind];
+/**
+ * Function type for creating custom complexity error messages.
+ *
+ * @param kind - The type of complexity limit that was exceeded
+ * @param limits - The maximum allowed value
+ * @param results - The actual value that exceeded the limit
+ * @returns A GraphQL error with a custom message
+ */
+type GetComplexityError = (kind: ComplexityErrorKind, limits: number, results: number) => GraphQLError;
+
+/**
+ * Configuration for query complexity limits.
+ */
+interface ComplexityLimit {
+    /** Maximum allowed query depth */
+    depth?: number;
+    /** Maximum allowed fields per level */
+    breadth?: number;
+    /** Maximum allowed total complexity score */
+    complexity?: number;
+}
+/**
+ * Function to determine complexity limits, can be static or context-based.
+ */
+type GetComplexityLimit<Context> = ComplexityLimit | ((ctx: Context) => ComplexityLimit | PromiseLike<ComplexityLimit>);
+
+/**
+ * Configuration options for the complexity extension.
+ */
+interface ComplexityExtensionOptions<Context> {
+    /** Static limits or function to determine limits based on context */
+    limit?: GetComplexityLimit<Context>;
+    /**
+     * Base complexity score for fields
+     * @defaultValue 1
+     */
+    defaultComplexity?: number;
+    /**
+     * Multiplier applied to list fields
+     * @defaultValue 10
+     */
+    defaultListMultiplier?: number;
+    /** Custom error message generator */
+    complexityError?: GetComplexityError;
+}
+
+interface ComplexityState {
+    fieldSettings: GetFieldSettings<unknown, unknown>;
+}
+declare global {
+    export namespace BaetaExtensions {
+        interface Extensions {
+            complexityExtension: ComplexityExtension<unknown>;
+        }
+    }
+}
+declare class ComplexityExtension<Ctx> extends Extension<ComplexityState> {
+    readonly stateKey: symbol;
+    private readonly options;
+    constructor(options?: ComplexityExtensionOptions<Ctx>);
+    getTypeExtensions: <Source, Context, Info>(builder: TypeBuilder<Source, Context, Info>) => BaetaExtensions.TypeExtensions<Source, Context, Info, TypeBuilder<Source, Context, Info>>;
+    getFieldExtensions: <Result, Source, Context, Args, Info>(builder: FieldBuilder<Result, Source, Context, Args, Info>) => BaetaExtensions.FieldExtensions<Result, Source, Context, Args, Info, FieldBuilder<Result, Source, Context, Args, Info>>;
+    getSubscriptionExtensions: <Result, Source, Context, Args, Info>(builder: SubscriptionBuilder<Result, Source, Context, Args, Info>) => BaetaExtensions.SubscriptionExtensions<Result, Source, Context, Args, Info, SubscriptionBuilder<Result, Source, Context, Args, Info>>;
+    mutate(compilers: ModuleCompiler[]): void;
+}
+
+/**
+ * Creates a complexity analysis extension for GraphQL queries.
+ *
+ * @param options - Configuration options for complexity analysis
+ * @returns Extension factory function
+ *
+ * @example
+ * ```typescript
+ * const complexity = complexityExtension<Context>({
+ *   defaultComplexity: 1,
+ *   defaultListMultiplier: 10,
+ *   limit: {
+ *     depth: 5,
+ *     breadth: 10,
+ *     complexity: 100
+ *   }
+ * });
+ * ```
+ */
+declare function complexityExtension<Ctx>(options?: ComplexityExtensionOptions<Ctx>): ComplexityExtension<Ctx>;
+
+export { ComplexityError, ComplexityErrorCode, ComplexityErrorKind, type ComplexityExtensionOptions, type ComplexityLimit, type FieldSettings, type GetComplexityError, type GetComplexityLimit, type GetFieldSettings, type GetFieldSettingsArgs, complexityExtension };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@baeta/extension-complexity",
-  "version": "2.0.0-next.1",
+  "version": "2.0.0-next.2",
   "keywords": [
     "baeta",
     "graphql",
@@ -45,14 +45,14 @@
   },
   "devDependencies": {
     "@baeta/builder": "^0.0.0",
-    "@baeta/core": "^2.0.0-next.1",
+    "@baeta/core": "^2.0.0-next.2",
     "@baeta/testing": "^0.0.0",
     "@baeta/tsconfig": "^0.0.0",
     "graphql": "^16.11.0",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {
-    "@baeta/core": "^2.0.0-next.1",
+    "@baeta/core": "^2.0.0-next.2",
     "graphql": "^16.6.0"
   },
   "engines": {