@leaven-graphql/plugins 0.1.0

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to the Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Pegasus Heavy Industries LLC
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,244 @@
+# @leaven-graphql/plugins
+
+Plugin system for extending Leaven with caching, logging, tracing, and more.
+
+## Installation
+
+```bash
+bun add @leaven-graphql/plugins
+```
+
+## Quick Start
+
+```typescript
+import { createLoggingPlugin, createDepthLimitPlugin } from '@leaven-graphql/plugins';
+import { LeavenExecutor } from '@leaven-graphql/core';
+
+const executor = new LeavenExecutor({
+  schema,
+  plugins: [
+    createLoggingPlugin({ logger: console }),
+    createDepthLimitPlugin({ maxDepth: 10 }),
+  ],
+});
+```
+
+## Built-in Plugins
+
+### Logging Plugin
+
+```typescript
+import { createLoggingPlugin } from '@leaven-graphql/plugins';
+
+const loggingPlugin = createLoggingPlugin({
+  logger: console,
+  logLevel: 'info',
+  includeVariables: false,
+  includeResult: false,
+});
+
+// Output:
+// [GraphQL] Query getUser started
+// [GraphQL] Query getUser completed in 15ms
+```
+
+### Tracing Plugin
+
+```typescript
+import { createTracingPlugin } from '@leaven-graphql/plugins';
+
+const tracingPlugin = createTracingPlugin({
+  includeResolvers: true,
+  includeValidation: true,
+});
+
+// Adds tracing to response extensions:
+// {
+//   extensions: {
+//     tracing: {
+//       version: 1,
+//       startTime: "2026-01-01T12:00:00.000Z",
+//       duration: 15000000,
+//       execution: { ... }
+//     }
+//   }
+// }
+```
+
+### Depth Limit Plugin
+
+```typescript
+import { createDepthLimitPlugin } from '@leaven-graphql/plugins';
+
+const depthLimitPlugin = createDepthLimitPlugin({
+  maxDepth: 10,
+  ignoreIntrospection: true,
+});
+
+// Rejects queries that are too deeply nested
+```
+
+### Complexity Plugin
+
+```typescript
+import { createComplexityPlugin } from '@leaven-graphql/plugins';
+
+const complexityPlugin = createComplexityPlugin({
+  maxComplexity: 1000,
+  defaultFieldComplexity: 1,
+  scalarCost: 0,
+  objectCost: 1,
+  listFactor: 10,
+});
+
+// Calculates and enforces query complexity
+```
+
+### Caching Plugin
+
+```typescript
+import { createCachingPlugin } from '@leaven-graphql/plugins';
+
+const cachingPlugin = createCachingPlugin({
+  ttl: 60000,           // Cache TTL in ms
+  maxSize: 100,         // Max cached responses
+  keyGenerator: (request) => {
+    return `${request.query}:${JSON.stringify(request.variables)}`;
+  },
+});
+```
+
+## Creating Custom Plugins
+
+```typescript
+import { createPlugin } from '@leaven-graphql/plugins';
+
+const metricsPlugin = createPlugin({
+  name: 'metrics',
+  version: '1.0.0',
+
+  beforeParse: (query, context) => {
+    context.startTime = performance.now();
+    return query;
+  },
+
+  afterExecute: (result, context) => {
+    const duration = performance.now() - context.startTime;
+
+    metrics.record({
+      operation: context.operationName,
+      duration,
+      errors: result.errors?.length ?? 0,
+    });
+
+    return result;
+  },
+
+  onError: (error, context) => {
+    metrics.recordError({
+      operation: context.operationName,
+      error: error.message,
+    });
+  },
+});
+```
+
+## Plugin Manager
+
+```typescript
+import { PluginManager, createPluginManager } from '@leaven-graphql/plugins';
+
+const manager = createPluginManager({
+  schema,
+  plugins: [
+    createLoggingPlugin({ logger: console }),
+    createTracingPlugin(),
+    createDepthLimitPlugin({ maxDepth: 10 }),
+  ],
+});
+
+// Register additional plugins
+manager.register(myCustomPlugin);
+
+// Unregister plugins
+manager.unregister('logging');
+
+// Get registered plugin names
+const plugins = manager.getPluginNames();
+```
+
+## Composing Plugins
+
+```typescript
+import { composePlugins } from '@leaven-graphql/plugins';
+
+const combinedPlugin = composePlugins([
+  createLoggingPlugin({ logger: console }),
+  createTracingPlugin(),
+  createDepthLimitPlugin({ maxDepth: 10 }),
+  createComplexityPlugin({ maxComplexity: 500 }),
+]);
+
+const executor = new LeavenExecutor({
+  schema,
+  plugins: [combinedPlugin],
+});
+```
+
+## Plugin Hooks
+
+| Hook | Description |
+|------|-------------|
+| `beforeParse` | Called before parsing the query string |
+| `afterParse` | Called after parsing, receives DocumentNode |
+| `beforeValidate` | Called before schema validation |
+| `afterValidate` | Called after validation with results |
+| `beforeExecute` | Called before resolver execution |
+| `afterExecute` | Called after execution with results |
+| `onError` | Called when an error occurs |
+
+## API Reference
+
+### Plugin Interface
+
+```typescript
+interface Plugin {
+  name: string;
+  version?: string;
+
+  beforeParse?(query: string, context: PluginContext): string | void;
+  afterParse?(document: DocumentNode, context: PluginContext): DocumentNode | void;
+  beforeValidate?(document: DocumentNode, context: PluginContext): void;
+  afterValidate?(result: ValidationResult, context: PluginContext): void;
+  beforeExecute?(context: PluginContext): void | Promise<void>;
+  afterExecute?(result: ExecutionResult, context: PluginContext): ExecutionResult | void;
+  onError?(error: Error, context: PluginContext): void;
+}
+```
+
+### createPlugin
+
+```typescript
+function createPlugin(config: Plugin): Plugin;
+```
+
+### composePlugins
+
+```typescript
+function composePlugins(plugins: Plugin[]): Plugin;
+```
+
+### PluginManager
+
+```typescript
+class PluginManager {
+  register(plugin: Plugin): void;
+  unregister(name: string): void;
+  getPluginNames(): string[];
+  execute<T>(hookName: string, ...args: unknown[]): T;
+}
+```
+
+## License
+
+Apache 2.0 - Pegasus Heavy Industries LLC

package/dist/builtin.d.ts

@@ -0,0 +1,58 @@
+/**
+ * @leaven-graphql/plugins - Built-in plugins
+ *
+ * Copyright 2026 Pegasus Heavy Industries LLC
+ * Licensed under the Apache License, Version 2.0
+ */
+import type { Plugin, PluginHooks, PluginMetadata } from './types';
+/**
+ * Create a custom plugin
+ */
+export declare function createPlugin(metadata: PluginMetadata, hooks: PluginHooks): Plugin;
+/**
+ * Compose multiple plugins into one
+ */
+export declare function composePlugins(name: string, ...plugins: Plugin[]): Plugin;
+/**
+ * Create a caching plugin
+ */
+export declare function createCachingPlugin(options?: {
+    /** Maximum cache size */
+    maxSize?: number;
+    /** Cache TTL in milliseconds */
+    ttl?: number;
+}): Plugin;
+/**
+ * Create a logging plugin
+ */
+export declare function createLoggingPlugin(options?: {
+    /** Log level */
+    level?: 'debug' | 'info' | 'warn' | 'error';
+    /** Custom logger */
+    logger?: {
+        debug: (msg: string, data?: unknown) => void;
+        info: (msg: string, data?: unknown) => void;
+        warn: (msg: string, data?: unknown) => void;
+        error: (msg: string, data?: unknown) => void;
+    };
+}): Plugin;
+/**
+ * Create a tracing plugin
+ */
+export declare function createTracingPlugin(): Plugin;
+/**
+ * Create a depth limit plugin
+ */
+export declare function createDepthLimitPlugin(maxDepth: number): Plugin;
+/**
+ * Create a complexity plugin
+ */
+export declare function createComplexityPlugin(options: {
+    /** Maximum allowed complexity */
+    maxComplexity: number;
+    /** Default field complexity */
+    defaultComplexity?: number;
+    /** Custom complexity calculator */
+    calculator?: (node: unknown, childComplexity: number) => number;
+}): Plugin;
+//# sourceMappingURL=builtin.d.ts.map

package/dist/builtin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin.d.ts","sourceRoot":"","sources":["../src/builtin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEnE;;GAEG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,cAAc,EACxB,KAAK,EAAE,WAAW,GACjB,MAAM,CAKR;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,EAAE,MAAM,EAAE,GAAG,MAAM,CA6EzE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE;IAC5C,yBAAyB;IACzB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gCAAgC;IAChC,GAAG,CAAC,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,CAsDT;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,CAAC,EAAE;IAC5C,gBAAgB;IAChB,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAC5C,oBAAoB;IACpB,MAAM,CAAC,EAAE;QACP,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;QAC7C,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;QAC5C,IAAI,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;QAC5C,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,KAAK,IAAI,CAAC;KAC9C,CAAC;CACH,GAAG,MAAM,CA6DT;AAED;;GAEG;AACH,wBAAgB,mBAAmB,IAAI,MAAM,CAsD5C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAuD/D;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE;IAC9C,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,+BAA+B;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;IAC3B,mCAAmC;IACnC,UAAU,CAAC,EAAE,CACX,IAAI,EAAE,OAAO,EACb,eAAe,EAAE,MAAM,KACpB,MAAM,CAAC;CACb,GAAG,MAAM,CA0ET"}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @leaven-graphql/plugins - Plugin system for Leaven
+ *
+ * Copyright 2026 Pegasus Heavy Industries LLC
+ * Licensed under the Apache License, Version 2.0
+ */
+export { PluginManager, createPluginManager } from './manager';
+export type { PluginManagerConfig } from './manager';
+export type { Plugin, PluginContext, PluginHooks, PluginMetadata, BeforeParseHook, AfterParseHook, BeforeValidateHook, AfterValidateHook, BeforeExecuteHook, AfterExecuteHook, OnErrorHook, } from './types';
+export { createPlugin, composePlugins, createCachingPlugin, createLoggingPlugin, createTracingPlugin, createDepthLimitPlugin, createComplexityPlugin, } from './builtin';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAC/D,YAAY,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAErD,YAAY,EACV,MAAM,EACN,aAAa,EACb,WAAW,EACX,cAAc,EACd,eAAe,EACf,cAAc,EACd,kBAAkB,EAClB,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,WAAW,GACZ,MAAM,SAAS,CAAC;AAEjB,OAAO,EACL,YAAY,EACZ,cAAc,EACd,mBAAmB,EACnB,mBAAmB,EACnB,mBAAmB,EACnB,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,WAAW,CAAC"}

package/dist/index.js

@@ -0,0 +1,531 @@
+// @bun
+// src/manager.ts
+class PluginManager {
+  schema;
+  plugins;
+  pluginOrder;
+  constructor(config) {
+    this.schema = config.schema;
+    this.plugins = new Map;
+    this.pluginOrder = [];
+    if (config.plugins) {
+      for (const plugin of config.plugins) {
+        this.register(plugin);
+      }
+    }
+  }
+  async register(plugin) {
+    const { name } = plugin.metadata;
+    if (this.plugins.has(name)) {
+      throw new Error(`Plugin "${name}" is already registered`);
+    }
+    if (plugin.metadata.dependencies) {
+      for (const dep of plugin.metadata.dependencies) {
+        if (!this.plugins.has(dep)) {
+          throw new Error(`Plugin "${name}" depends on "${dep}" which is not registered`);
+        }
+      }
+    }
+    this.plugins.set(name, plugin);
+    this.pluginOrder.push(name);
+    await plugin.onRegister?.(this.schema);
+  }
+  async unregister(name) {
+    const plugin = this.plugins.get(name);
+    if (!plugin) {
+      return false;
+    }
+    for (const [otherName, otherPlugin] of this.plugins) {
+      if (otherPlugin.metadata.dependencies?.includes(name) && otherName !== name) {
+        throw new Error(`Cannot unregister "${name}": "${otherName}" depends on it`);
+      }
+    }
+    await plugin.onUnregister?.();
+    this.plugins.delete(name);
+    const index = this.pluginOrder.indexOf(name);
+    if (index !== -1) {
+      this.pluginOrder.splice(index, 1);
+    }
+    return true;
+  }
+  get(name) {
+    return this.plugins.get(name);
+  }
+  has(name) {
+    return this.plugins.has(name);
+  }
+  getPluginNames() {
+    return [...this.pluginOrder];
+  }
+  createContext(request, userContext) {
+    return {
+      schema: this.schema,
+      request,
+      context: userContext,
+      state: new Map
+    };
+  }
+  async beforeParse(query, context) {
+    let result = query;
+    for (const name of this.pluginOrder) {
+      const plugin = this.plugins.get(name);
+      if (plugin.beforeParse) {
+        const modified = await plugin.beforeParse(result, context);
+        if (typeof modified === "string") {
+          result = modified;
+        }
+      }
+    }
+    return result;
+  }
+  async afterParse(document, context) {
+    let result = document;
+    for (const name of this.pluginOrder) {
+      const plugin = this.plugins.get(name);
+      if (plugin.afterParse) {
+        const modified = await plugin.afterParse(result, context);
+        if (modified) {
+          result = modified;
+        }
+      }
+    }
+    return result;
+  }
+  async beforeValidate(document, context) {
+    for (const name of this.pluginOrder) {
+      const plugin = this.plugins.get(name);
+      if (plugin.beforeValidate) {
+        await plugin.beforeValidate(document, context);
+      }
+    }
+  }
+  async afterValidate(result, context) {
+    for (const name of this.pluginOrder) {
+      const plugin = this.plugins.get(name);
+      if (plugin.afterValidate) {
+        await plugin.afterValidate(result, context);
+      }
+    }
+  }
+  async beforeExecute(document, context) {
+    for (const name of this.pluginOrder) {
+      const plugin = this.plugins.get(name);
+      if (plugin.beforeExecute) {
+        await plugin.beforeExecute(document, context);
+      }
+    }
+  }
+  async afterExecute(response, context) {
+    let result = response;
+    for (let i = this.pluginOrder.length - 1;i >= 0; i--) {
+      const name = this.pluginOrder[i];
+      const plugin = this.plugins.get(name);
+      if (plugin.afterExecute) {
+        const modified = await plugin.afterExecute(result, context);
+        if (modified) {
+          result = modified;
+        }
+      }
+    }
+    return result;
+  }
+  async onError(error, context) {
+    let result = error;
+    for (const name of this.pluginOrder) {
+      const plugin = this.plugins.get(name);
+      if (plugin.onError) {
+        const modified = await plugin.onError(result, context);
+        if (modified instanceof Error) {
+          result = modified;
+        }
+      }
+    }
+    return result;
+  }
+  get size() {
+    return this.plugins.size;
+  }
+  async clear() {
+    for (let i = this.pluginOrder.length - 1;i >= 0; i--) {
+      await this.unregister(this.pluginOrder[i]);
+    }
+  }
+}
+function createPluginManager(config) {
+  return new PluginManager(config);
+}
+// ../../node_modules/.pnpm/graphql@16.12.0/node_modules/graphql/language/kinds.mjs
+var Kind;
+(function(Kind2) {
+  Kind2["NAME"] = "Name";
+  Kind2["DOCUMENT"] = "Document";
+  Kind2["OPERATION_DEFINITION"] = "OperationDefinition";
+  Kind2["VARIABLE_DEFINITION"] = "VariableDefinition";
+  Kind2["SELECTION_SET"] = "SelectionSet";
+  Kind2["FIELD"] = "Field";
+  Kind2["ARGUMENT"] = "Argument";
+  Kind2["FRAGMENT_SPREAD"] = "FragmentSpread";
+  Kind2["INLINE_FRAGMENT"] = "InlineFragment";
+  Kind2["FRAGMENT_DEFINITION"] = "FragmentDefinition";
+  Kind2["VARIABLE"] = "Variable";
+  Kind2["INT"] = "IntValue";
+  Kind2["FLOAT"] = "FloatValue";
+  Kind2["STRING"] = "StringValue";
+  Kind2["BOOLEAN"] = "BooleanValue";
+  Kind2["NULL"] = "NullValue";
+  Kind2["ENUM"] = "EnumValue";
+  Kind2["LIST"] = "ListValue";
+  Kind2["OBJECT"] = "ObjectValue";
+  Kind2["OBJECT_FIELD"] = "ObjectField";
+  Kind2["DIRECTIVE"] = "Directive";
+  Kind2["NAMED_TYPE"] = "NamedType";
+  Kind2["LIST_TYPE"] = "ListType";
+  Kind2["NON_NULL_TYPE"] = "NonNullType";
+  Kind2["SCHEMA_DEFINITION"] = "SchemaDefinition";
+  Kind2["OPERATION_TYPE_DEFINITION"] = "OperationTypeDefinition";
+  Kind2["SCALAR_TYPE_DEFINITION"] = "ScalarTypeDefinition";
+  Kind2["OBJECT_TYPE_DEFINITION"] = "ObjectTypeDefinition";
+  Kind2["FIELD_DEFINITION"] = "FieldDefinition";
+  Kind2["INPUT_VALUE_DEFINITION"] = "InputValueDefinition";
+  Kind2["INTERFACE_TYPE_DEFINITION"] = "InterfaceTypeDefinition";
+  Kind2["UNION_TYPE_DEFINITION"] = "UnionTypeDefinition";
+  Kind2["ENUM_TYPE_DEFINITION"] = "EnumTypeDefinition";
+  Kind2["ENUM_VALUE_DEFINITION"] = "EnumValueDefinition";
+  Kind2["INPUT_OBJECT_TYPE_DEFINITION"] = "InputObjectTypeDefinition";
+  Kind2["DIRECTIVE_DEFINITION"] = "DirectiveDefinition";
+  Kind2["SCHEMA_EXTENSION"] = "SchemaExtension";
+  Kind2["SCALAR_TYPE_EXTENSION"] = "ScalarTypeExtension";
+  Kind2["OBJECT_TYPE_EXTENSION"] = "ObjectTypeExtension";
+  Kind2["INTERFACE_TYPE_EXTENSION"] = "InterfaceTypeExtension";
+  Kind2["UNION_TYPE_EXTENSION"] = "UnionTypeExtension";
+  Kind2["ENUM_TYPE_EXTENSION"] = "EnumTypeExtension";
+  Kind2["INPUT_OBJECT_TYPE_EXTENSION"] = "InputObjectTypeExtension";
+  Kind2["TYPE_COORDINATE"] = "TypeCoordinate";
+  Kind2["MEMBER_COORDINATE"] = "MemberCoordinate";
+  Kind2["ARGUMENT_COORDINATE"] = "ArgumentCoordinate";
+  Kind2["DIRECTIVE_COORDINATE"] = "DirectiveCoordinate";
+  Kind2["DIRECTIVE_ARGUMENT_COORDINATE"] = "DirectiveArgumentCoordinate";
+})(Kind || (Kind = {}));
+// src/builtin.ts
+function createPlugin(metadata, hooks) {
+  return {
+    metadata,
+    ...hooks
+  };
+}
+function composePlugins(name, ...plugins) {
+  return {
+    metadata: {
+      name,
+      description: `Composed plugin from: ${plugins.map((p) => p.metadata.name).join(", ")}`
+    },
+    async onRegister(schema) {
+      for (const plugin of plugins) {
+        await plugin.onRegister?.(schema);
+      }
+    },
+    async onUnregister() {
+      for (const plugin of plugins) {
+        await plugin.onUnregister?.();
+      }
+    },
+    async beforeParse(query, context) {
+      let result = query;
+      for (const plugin of plugins) {
+        if (plugin.beforeParse) {
+          const modified = await plugin.beforeParse(result, context);
+          if (typeof modified === "string") {
+            result = modified;
+          }
+        }
+      }
+      return result;
+    },
+    async afterParse(document, context) {
+      let result = document;
+      for (const plugin of plugins) {
+        if (plugin.afterParse) {
+          const modified = await plugin.afterParse(result, context);
+          if (modified) {
+            result = modified;
+          }
+        }
+      }
+      return result;
+    },
+    async beforeExecute(document, context) {
+      for (const plugin of plugins) {
+        await plugin.beforeExecute?.(document, context);
+      }
+    },
+    async afterExecute(response, context) {
+      let result = response;
+      for (const plugin of plugins.slice().reverse()) {
+        if (plugin.afterExecute) {
+          const modified = await plugin.afterExecute(result, context);
+          if (modified) {
+            result = modified;
+          }
+        }
+      }
+      return result;
+    },
+    async onError(error, context) {
+      let result = error;
+      for (const plugin of plugins) {
+        if (plugin.onError) {
+          const modified = await plugin.onError(result, context);
+          if (modified instanceof Error) {
+            result = modified;
+          }
+        }
+      }
+      return result;
+    }
+  };
+}
+function createCachingPlugin(options) {
+  const cache = new Map;
+  const maxSize = options?.maxSize ?? 100;
+  const ttl = options?.ttl ?? 60000;
+  return {
+    metadata: {
+      name: "caching",
+      version: "1.0.0",
+      description: "Caches query results"
+    },
+    async beforeExecute(document, context) {
+      const key = JSON.stringify({
+        query: context.request.query,
+        variables: context.request.variables
+      });
+      const cached = cache.get(key);
+      if (cached && cached.expires > Date.now()) {
+        context.state.set("cacheHit", true);
+        context.state.set("cachedResponse", cached.data);
+      }
+    },
+    async afterExecute(response, context) {
+      if (context.state.get("cacheHit")) {
+        return context.state.get("cachedResponse");
+      }
+      if (response.errors && response.errors.length > 0) {
+        return response;
+      }
+      const key = JSON.stringify({
+        query: context.request.query,
+        variables: context.request.variables
+      });
+      if (cache.size >= maxSize) {
+        const firstKey = cache.keys().next().value;
+        if (firstKey)
+          cache.delete(firstKey);
+      }
+      cache.set(key, {
+        data: response,
+        expires: Date.now() + ttl
+      });
+      return response;
+    }
+  };
+}
+function createLoggingPlugin(options) {
+  const logger = options?.logger ?? console;
+  const level = options?.level ?? "info";
+  const shouldLog = (msgLevel) => {
+    const levels = ["debug", "info", "warn", "error"];
+    return levels.indexOf(msgLevel) >= levels.indexOf(level);
+  };
+  return {
+    metadata: {
+      name: "logging",
+      version: "1.0.0",
+      description: "Logs GraphQL operations"
+    },
+    async beforeExecute(document, context) {
+      context.state.set("startTime", performance.now());
+      if (shouldLog("debug")) {
+        logger.debug("Executing GraphQL operation", {
+          operationName: context.request.operationName,
+          query: context.request.query
+        });
+      }
+    },
+    async afterExecute(response, context) {
+      const startTime = context.state.get("startTime");
+      const duration = performance.now() - startTime;
+      if (response.errors && response.errors.length > 0) {
+        if (shouldLog("error")) {
+          logger.error("GraphQL operation completed with errors", {
+            operationName: context.request.operationName,
+            duration: `${duration.toFixed(2)}ms`,
+            errors: response.errors
+          });
+        }
+      } else {
+        if (shouldLog("info")) {
+          logger.info("GraphQL operation completed", {
+            operationName: context.request.operationName,
+            duration: `${duration.toFixed(2)}ms`
+          });
+        }
+      }
+      return response;
+    },
+    async onError(error, context) {
+      if (shouldLog("error")) {
+        logger.error("GraphQL operation failed", {
+          operationName: context.request.operationName,
+          error: error.message
+        });
+      }
+      return error;
+    }
+  };
+}
+function createTracingPlugin() {
+  return {
+    metadata: {
+      name: "tracing",
+      version: "1.0.0",
+      description: "Adds tracing information to responses"
+    },
+    async beforeExecute(document, context) {
+      context.state.set("tracing", {
+        version: 1,
+        startTime: new Date().toISOString(),
+        startHrTime: process.hrtime.bigint(),
+        parsing: { startOffset: 0, duration: 0 },
+        validation: { startOffset: 0, duration: 0 },
+        execution: { startOffset: 0, duration: 0 }
+      });
+    },
+    async afterExecute(response, context) {
+      const tracing = context.state.get("tracing");
+      if (!tracing)
+        return response;
+      const endHrTime = process.hrtime.bigint();
+      const duration = Number(endHrTime - tracing.startHrTime);
+      return {
+        ...response,
+        extensions: {
+          ...response.extensions,
+          tracing: {
+            version: tracing.version,
+            startTime: tracing.startTime,
+            endTime: new Date().toISOString(),
+            duration,
+            parsing: tracing.parsing,
+            validation: tracing.validation,
+            execution: {
+              ...tracing.execution,
+              duration
+            }
+          }
+        }
+      };
+    }
+  };
+}
+function createDepthLimitPlugin(maxDepth) {
+  function calculateDepth(node, currentDepth = 0) {
+    if (!node || typeof node !== "object")
+      return currentDepth;
+    const typedNode = node;
+    let maxFoundDepth = currentDepth;
+    if (typedNode.kind === Kind.FIELD) {
+      maxFoundDepth = currentDepth + 1;
+    }
+    if (typedNode.selectionSet) {
+      for (const selection of typedNode.selectionSet.selections) {
+        const depth = calculateDepth(selection, maxFoundDepth);
+        if (depth > maxFoundDepth) {
+          maxFoundDepth = depth;
+        }
+      }
+    }
+    return maxFoundDepth;
+  }
+  return {
+    metadata: {
+      name: "depth-limit",
+      version: "1.0.0",
+      description: `Limits query depth to ${maxDepth}`
+    },
+    async afterParse(document, _context) {
+      let depth = 0;
+      for (const definition of document.definitions) {
+        if (definition.kind === Kind.OPERATION_DEFINITION) {
+          const opDepth = calculateDepth(definition, 0);
+          if (opDepth > depth) {
+            depth = opDepth;
+          }
+        }
+      }
+      if (depth > maxDepth) {
+        throw new Error(`Query depth of ${depth} exceeds maximum allowed depth of ${maxDepth}`);
+      }
+      return document;
+    }
+  };
+}
+function createComplexityPlugin(options) {
+  const { maxComplexity, defaultComplexity = 1 } = options;
+  function calculateComplexity(node, depth = 0) {
+    if (!node || typeof node !== "object")
+      return 0;
+    const typedNode = node;
+    let complexity = 0;
+    if (typedNode.kind === Kind.FIELD) {
+      let multiplier = 1;
+      if (typedNode.arguments) {
+        for (const arg of typedNode.arguments) {
+          if (arg.name.value === "first" || arg.name.value === "last" || arg.name.value === "limit") {
+            const value = parseInt(arg.value.value ?? "10", 10);
+            if (!isNaN(value)) {
+              multiplier = value;
+            }
+          }
+        }
+      }
+      complexity = defaultComplexity * multiplier;
+    }
+    if (typedNode.selectionSet) {
+      for (const selection of typedNode.selectionSet.selections) {
+        complexity += calculateComplexity(selection, depth + 1);
+      }
+    }
+    return complexity;
+  }
+  return {
+    metadata: {
+      name: "complexity",
+      version: "1.0.0",
+      description: `Limits query complexity to ${maxComplexity}`
+    },
+    async afterParse(document, context) {
+      let totalComplexity = 0;
+      for (const definition of document.definitions) {
+        if (definition.kind === Kind.OPERATION_DEFINITION) {
+          totalComplexity += calculateComplexity(definition, 0);
+        }
+      }
+      context.state.set("complexity", totalComplexity);
+      if (totalComplexity > maxComplexity) {
+        throw new Error(`Query complexity of ${totalComplexity} exceeds maximum allowed complexity of ${maxComplexity}`);
+      }
+      return document;
+    }
+  };
+}
+export {
+  createTracingPlugin,
+  createPluginManager,
+  createPlugin,
+  createLoggingPlugin,
+  createDepthLimitPlugin,
+  createComplexityPlugin,
+  createCachingPlugin,
+  composePlugins,
+  PluginManager
+};

package/dist/manager.d.ts

@@ -0,0 +1,95 @@
+/**
+ * @leaven-graphql/plugins - Plugin manager
+ *
+ * Copyright 2026 Pegasus Heavy Industries LLC
+ * Licensed under the Apache License, Version 2.0
+ */
+import type { DocumentNode, GraphQLSchema, GraphQLError } from 'graphql';
+import type { GraphQLRequest, GraphQLResponse } from '@leaven-graphql/core';
+import type { Plugin, PluginContext } from './types';
+/**
+ * Plugin manager configuration
+ */
+export interface PluginManagerConfig {
+    /** GraphQL schema */
+    schema: GraphQLSchema;
+    /** Initial plugins to register */
+    plugins?: Plugin[];
+}
+/**
+ * Manages plugins and executes hooks
+ */
+export declare class PluginManager {
+    private readonly schema;
+    private readonly plugins;
+    private readonly pluginOrder;
+    constructor(config: PluginManagerConfig);
+    /**
+     * Register a plugin
+     */
+    register(plugin: Plugin): Promise<void>;
+    /**
+     * Unregister a plugin
+     */
+    unregister(name: string): Promise<boolean>;
+    /**
+     * Get a plugin by name
+     */
+    get(name: string): Plugin | undefined;
+    /**
+     * Check if a plugin is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Get all registered plugin names
+     */
+    getPluginNames(): string[];
+    /**
+     * Create a plugin context
+     */
+    createContext<TContext>(request: GraphQLRequest, userContext: TContext): PluginContext<TContext>;
+    /**
+     * Execute beforeParse hooks
+     */
+    beforeParse(query: string, context: PluginContext): Promise<string>;
+    /**
+     * Execute afterParse hooks
+     */
+    afterParse(document: DocumentNode, context: PluginContext): Promise<DocumentNode>;
+    /**
+     * Execute beforeValidate hooks
+     */
+    beforeValidate(document: DocumentNode, context: PluginContext): Promise<void>;
+    /**
+     * Execute afterValidate hooks
+     */
+    afterValidate(result: {
+        valid: boolean;
+        errors: readonly GraphQLError[];
+    }, context: PluginContext): Promise<void>;
+    /**
+     * Execute beforeExecute hooks
+     */
+    beforeExecute(document: DocumentNode, context: PluginContext): Promise<void>;
+    /**
+     * Execute afterExecute hooks
+     */
+    afterExecute(response: GraphQLResponse, context: PluginContext): Promise<GraphQLResponse>;
+    /**
+     * Execute onError hooks
+     */
+    onError(error: Error, context: PluginContext): Promise<Error>;
+    /**
+     * Get the number of registered plugins
+     */
+    get size(): number;
+    /**
+     * Clear all plugins
+     */
+    clear(): Promise<void>;
+}
+/**
+ * Create a new plugin manager
+ */
+export declare function createPluginManager(config: PluginManagerConfig): PluginManager;
+//# sourceMappingURL=manager.d.ts.map

package/dist/manager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.d.ts","sourceRoot":"","sources":["../src/manager.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AACzE,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAC5E,OAAO,KAAK,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAErD;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,qBAAqB;IACrB,MAAM,EAAE,aAAa,CAAC;IACtB,kCAAkC;IAClC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAgB;IACvC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAsB;IAC9C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAW;gBAE3B,MAAM,EAAE,mBAAmB;IAavC;;OAEG;IACU,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAyBpD;;OAEG;IACU,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IA8BvD;;OAEG;IACI,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IAI5C;;OAEG;IACI,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC;;OAEG;IACI,cAAc,IAAI,MAAM,EAAE;IAIjC;;OAEG;IACI,aAAa,CAAC,QAAQ,EAC3B,OAAO,EAAE,cAAc,EACvB,WAAW,EAAE,QAAQ,GACpB,aAAa,CAAC,QAAQ,CAAC;IAS1B;;OAEG;IACU,WAAW,CACtB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,MAAM,CAAC;IAgBlB;;OAEG;IACU,UAAU,CACrB,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,YAAY,CAAC;IAgBxB;;OAEG;IACU,cAAc,CACzB,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC;IAShB;;OAEG;IACU,aAAa,CACxB,MAAM,EAAE;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAA;KAAE,EAC3D,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC;IAShB;;OAEG;IACU,aAAa,CACxB,QAAQ,EAAE,YAAY,EACtB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,IAAI,CAAC;IAShB;;OAEG;IACU,YAAY,CACvB,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,aAAa,GACrB,OAAO,CAAC,eAAe,CAAC;IAkB3B;;OAEG;IACU,OAAO,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC;IAgB1E;;OAEG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;OAEG;IACU,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAMpC;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,mBAAmB,GAAG,aAAa,CAE9E"}

package/dist/types.d.ts

@@ -0,0 +1,96 @@
+/**
+ * @leaven-graphql/plugins - Plugin types
+ *
+ * Copyright 2026 Pegasus Heavy Industries LLC
+ * Licensed under the Apache License, Version 2.0
+ */
+import type { DocumentNode, GraphQLSchema, GraphQLError } from 'graphql';
+import type { GraphQLRequest, GraphQLResponse } from '@leaven-graphql/core';
+/**
+ * Plugin metadata
+ */
+export interface PluginMetadata {
+    /** Unique plugin name */
+    name: string;
+    /** Plugin version */
+    version?: string;
+    /** Plugin description */
+    description?: string;
+    /** Plugin dependencies */
+    dependencies?: string[];
+}
+/**
+ * Plugin context available to hooks
+ */
+export interface PluginContext<TContext = unknown> {
+    /** The GraphQL schema */
+    schema: GraphQLSchema;
+    /** The original request */
+    request: GraphQLRequest;
+    /** User context */
+    context: TContext;
+    /** Additional data shared between hooks */
+    state: Map<string, unknown>;
+}
+/**
+ * Hook called before parsing
+ */
+export type BeforeParseHook = (query: string, context: PluginContext) => string | void | Promise<string | void>;
+/**
+ * Hook called after parsing
+ */
+export type AfterParseHook = (document: DocumentNode, context: PluginContext) => DocumentNode | void | Promise<DocumentNode | void>;
+/**
+ * Hook called before validation
+ */
+export type BeforeValidateHook = (document: DocumentNode, context: PluginContext) => void | Promise<void>;
+/**
+ * Hook called after validation
+ */
+export type AfterValidateHook = (result: {
+    valid: boolean;
+    errors: readonly GraphQLError[];
+}, context: PluginContext) => void | Promise<void>;
+/**
+ * Hook called before execution
+ */
+export type BeforeExecuteHook = (document: DocumentNode, context: PluginContext) => void | Promise<void>;
+/**
+ * Hook called after execution
+ */
+export type AfterExecuteHook = (response: GraphQLResponse, context: PluginContext) => GraphQLResponse | void | Promise<GraphQLResponse | void>;
+/**
+ * Hook called on error
+ */
+export type OnErrorHook = (error: Error, context: PluginContext) => Error | void | Promise<Error | void>;
+/**
+ * Plugin hooks
+ */
+export interface PluginHooks {
+    /** Called before parsing the query */
+    beforeParse?: BeforeParseHook;
+    /** Called after parsing the query */
+    afterParse?: AfterParseHook;
+    /** Called before validating the document */
+    beforeValidate?: BeforeValidateHook;
+    /** Called after validating the document */
+    afterValidate?: AfterValidateHook;
+    /** Called before executing the operation */
+    beforeExecute?: BeforeExecuteHook;
+    /** Called after executing the operation */
+    afterExecute?: AfterExecuteHook;
+    /** Called when an error occurs */
+    onError?: OnErrorHook;
+}
+/**
+ * Plugin interface
+ */
+export interface Plugin extends PluginHooks {
+    /** Plugin metadata */
+    metadata: PluginMetadata;
+    /** Called when plugin is registered */
+    onRegister?: (schema: GraphQLSchema) => void | Promise<void>;
+    /** Called when plugin is unregistered */
+    onUnregister?: () => void | Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@leaven-graphql/plugins",
+  "version": "0.1.0",
+  "description": "Plugin system for Leaven GraphQL",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "keywords": [
+    "graphql",
+    "bun",
+    "plugins"
+  ],
+  "author": "Pegasus Heavy Industries LLC",
+  "license": "Apache-2.0",
+  "dependencies": {
+    "graphql": "^16.8.0",
+    "@leaven-graphql/core": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.1.0",
+    "typescript": "^5.3.0"
+  },
+  "peerDependencies": {
+    "graphql": "^16.0.0"
+  },
+  "scripts": {
+    "build": "bun build ./src/index.ts --outdir ./dist --target bun && tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit"
+  }
+}