@graphql-yoga/plugin-apollo-usage-report 0.13.0 → 0.13.1-alpha-20260116132831-dc9fc0ad2f1ad6ee99bc438c173cf8496ae505a7

package/dist/stats.d.mts

@@ -0,0 +1,123 @@
+import { ReferencedFieldsByType } from "@apollo/utils.usagereporting";
+import { IContextualizedStats, IFieldStat, IPathErrorStats, IQueryLatencyStats, IReport, IStatsContext, ITracesAndStats, ITypeStat, ReportHeader, Trace, google } from "@apollo/usage-reporting-protobuf";
+import { NonFtv1ErrorPath } from "@apollo/server-gateway-interface";
+
+//#region src/stats.d.ts
+declare class SizeEstimator {
+  bytes: number;
+}
+declare class OurReport implements Required<IReport> {
+  readonly header: ReportHeader;
+  tracesPreAggregated: boolean;
+  constructor(header: ReportHeader);
+  readonly tracesPerQuery: Record<string, OurTracesAndStats>;
+  endTime: google.protobuf.ITimestamp | null;
+  operationCount: number;
+  readonly sizeEstimator: SizeEstimator;
+  ensureCountsAreIntegers(): void;
+  addTrace({
+    statsReportKey,
+    trace,
+    asTrace,
+    referencedFieldsByType,
+    maxTraceBytes,
+    nonFtv1ErrorPaths
+  }: {
+    statsReportKey: string;
+    trace: Trace;
+    asTrace: boolean;
+    referencedFieldsByType: ReferencedFieldsByType;
+    maxTraceBytes?: number;
+    nonFtv1ErrorPaths: NonFtv1ErrorPath[];
+  }): void;
+  private getTracesAndStats;
+}
+declare class OurTracesAndStats implements Required<ITracesAndStats> {
+  readonly referencedFieldsByType: ReferencedFieldsByType;
+  constructor(referencedFieldsByType: ReferencedFieldsByType);
+  readonly trace: Uint8Array[];
+  readonly statsWithContext: StatsByContext;
+  readonly internalTracesContributingToStats: Uint8Array[];
+  ensureCountsAreIntegers(): void;
+}
+declare class StatsByContext {
+  readonly map: {
+    [k: string]: OurContextualizedStats;
+  };
+  /**
+   * This function is used by the protobuf generator to convert this map into
+   * an array of contextualized stats to serialize
+   */
+  toArray(): IContextualizedStats[];
+  ensureCountsAreIntegers(): void;
+  addTrace(trace: Trace, sizeEstimator: SizeEstimator, nonFtv1ErrorPaths: NonFtv1ErrorPath[]): void;
+  private getContextualizedStats;
+}
+declare class OurContextualizedStats implements Required<IContextualizedStats> {
+  readonly context: IStatsContext;
+  queryLatencyStats: OurQueryLatencyStats;
+  perTypeStat: {
+    [k: string]: OurTypeStat;
+  };
+  constructor(context: IStatsContext);
+  ensureCountsAreIntegers(): void;
+  addTrace(trace: Trace, sizeEstimator: SizeEstimator, nonFtv1ErrorPaths?: NonFtv1ErrorPath[]): void;
+  getTypeStat(parentType: string, sizeEstimator: SizeEstimator): OurTypeStat;
+}
+declare class OurQueryLatencyStats implements Required<IQueryLatencyStats> {
+  latencyCount: DurationHistogram;
+  requestCount: number;
+  requestsWithoutFieldInstrumentation: number;
+  cacheHits: number;
+  persistedQueryHits: number;
+  persistedQueryMisses: number;
+  cacheLatencyCount: DurationHistogram;
+  rootErrorStats: OurPathErrorStats;
+  requestsWithErrorsCount: number;
+  publicCacheTtlCount: DurationHistogram;
+  privateCacheTtlCount: DurationHistogram;
+  registeredOperationCount: number;
+  forbiddenOperationCount: number;
+}
+declare class OurPathErrorStats implements Required<IPathErrorStats> {
+  children: {
+    [k: string]: OurPathErrorStats;
+  };
+  errorsCount: number;
+  requestsWithErrorsCount: number;
+  getChild(subPath: string, sizeEstimator: SizeEstimator): OurPathErrorStats;
+}
+declare class OurTypeStat implements Required<ITypeStat> {
+  perFieldStat: {
+    [k: string]: OurFieldStat;
+  };
+  getFieldStat(fieldName: string, returnType: string, sizeEstimator: SizeEstimator): OurFieldStat;
+  ensureCountsAreIntegers(): void;
+}
+declare class OurFieldStat implements Required<IFieldStat> {
+  readonly returnType: string;
+  errorsCount: number;
+  observedExecutionCount: number;
+  estimatedExecutionCount: number;
+  requestsWithErrorsCount: number;
+  latencyCount: DurationHistogram;
+  constructor(returnType: string);
+  ensureCountsAreIntegers(): void;
+}
+interface DurationHistogramOptions {
+  initSize?: number;
+  buckets?: number[];
+}
+declare class DurationHistogram {
+  private readonly buckets;
+  static readonly BUCKET_COUNT = 384;
+  static readonly EXPONENT_LOG: number;
+  toArray(): number[];
+  static durationToBucket(durationNs: number): number;
+  incrementDuration(durationNs: number, value?: number): DurationHistogram;
+  incrementBucket(bucket: number, value?: number): void;
+  combine(otherHistogram: DurationHistogram): void;
+  constructor(options?: DurationHistogramOptions);
+}
+//#endregion
+export { OurReport };

package/dist/stats.mjs

@@ -0,0 +1,344 @@
+import { Trace } from "@apollo/usage-reporting-protobuf";
+
+//#region src/stats.ts
+var SizeEstimator = class {
+	bytes = 0;
+};
+var OurReport = class {
+	tracesPreAggregated = false;
+	constructor(header) {
+		this.header = header;
+	}
+	tracesPerQuery = Object.create(null);
+	endTime = null;
+	operationCount = 0;
+	sizeEstimator = new SizeEstimator();
+	ensureCountsAreIntegers() {
+		for (const tracesAndStats of Object.values(this.tracesPerQuery)) tracesAndStats.ensureCountsAreIntegers();
+	}
+	addTrace({ statsReportKey, trace, asTrace, referencedFieldsByType, maxTraceBytes = 10 * 1024 * 1024, nonFtv1ErrorPaths }) {
+		const tracesAndStats = this.getTracesAndStats({
+			statsReportKey,
+			referencedFieldsByType
+		});
+		if (asTrace) {
+			const encodedTrace = Trace.encode(trace).finish();
+			if (!isNaN(maxTraceBytes) && encodedTrace.length > maxTraceBytes) tracesAndStats.statsWithContext.addTrace(trace, this.sizeEstimator, nonFtv1ErrorPaths);
+			else {
+				tracesAndStats.trace.push(encodedTrace);
+				this.sizeEstimator.bytes += 2 + encodedTrace.length;
+			}
+		} else tracesAndStats.statsWithContext.addTrace(trace, this.sizeEstimator, nonFtv1ErrorPaths);
+	}
+	getTracesAndStats({ statsReportKey, referencedFieldsByType }) {
+		const existing = this.tracesPerQuery[statsReportKey];
+		if (existing) return existing;
+		this.sizeEstimator.bytes += estimatedBytesForString(statsReportKey);
+		for (const [typeName, referencedFieldsForType] of Object.entries(referencedFieldsByType)) {
+			this.sizeEstimator.bytes += 4;
+			if (referencedFieldsForType.isInterface) this.sizeEstimator.bytes += 2;
+			this.sizeEstimator.bytes += estimatedBytesForString(typeName);
+			for (const fieldName of referencedFieldsForType.fieldNames) this.sizeEstimator.bytes += estimatedBytesForString(fieldName);
+		}
+		return this.tracesPerQuery[statsReportKey] = new OurTracesAndStats(referencedFieldsByType);
+	}
+};
+var OurTracesAndStats = class {
+	constructor(referencedFieldsByType) {
+		this.referencedFieldsByType = referencedFieldsByType;
+	}
+	trace = [];
+	statsWithContext = new StatsByContext();
+	internalTracesContributingToStats = [];
+	ensureCountsAreIntegers() {
+		this.statsWithContext.ensureCountsAreIntegers();
+	}
+};
+var StatsByContext = class {
+	map = Object.create(null);
+	/**
+	* This function is used by the protobuf generator to convert this map into
+	* an array of contextualized stats to serialize
+	*/
+	toArray() {
+		return Object.values(this.map);
+	}
+	ensureCountsAreIntegers() {
+		for (const contextualizedStats of Object.values(this.map)) contextualizedStats.ensureCountsAreIntegers();
+	}
+	addTrace(trace, sizeEstimator, nonFtv1ErrorPaths) {
+		this.getContextualizedStats(trace, sizeEstimator).addTrace(trace, sizeEstimator, nonFtv1ErrorPaths);
+	}
+	getContextualizedStats(trace, sizeEstimator) {
+		const statsContext = {
+			clientName: trace.clientName,
+			clientVersion: trace.clientVersion
+		};
+		const statsContextKey = JSON.stringify(statsContext);
+		const existing = this.map[statsContextKey];
+		if (existing) return existing;
+		sizeEstimator.bytes += 20 + estimatedBytesForString(trace.clientName) + estimatedBytesForString(trace.clientVersion);
+		const contextualizedStats = new OurContextualizedStats(statsContext);
+		this.map[statsContextKey] = contextualizedStats;
+		return contextualizedStats;
+	}
+};
+var OurContextualizedStats = class {
+	queryLatencyStats = new OurQueryLatencyStats();
+	perTypeStat = Object.create(null);
+	constructor(context) {
+		this.context = context;
+	}
+	ensureCountsAreIntegers() {
+		for (const typeStat of Object.values(this.perTypeStat)) typeStat.ensureCountsAreIntegers();
+	}
+	addTrace(trace, sizeEstimator, nonFtv1ErrorPaths = []) {
+		const { fieldExecutionWeight } = trace;
+		if (!fieldExecutionWeight) this.queryLatencyStats.requestsWithoutFieldInstrumentation++;
+		this.queryLatencyStats.requestCount++;
+		if (trace.fullQueryCacheHit) {
+			this.queryLatencyStats.cacheLatencyCount.incrementDuration(trace.durationNs);
+			this.queryLatencyStats.cacheHits++;
+		} else this.queryLatencyStats.latencyCount.incrementDuration(trace.durationNs);
+		if (!trace.fullQueryCacheHit && trace.cachePolicy?.maxAgeNs != null) switch (trace.cachePolicy.scope) {
+			case Trace.CachePolicy.Scope.PRIVATE:
+				this.queryLatencyStats.privateCacheTtlCount.incrementDuration(trace.cachePolicy.maxAgeNs);
+				break;
+			case Trace.CachePolicy.Scope.PUBLIC:
+				this.queryLatencyStats.publicCacheTtlCount.incrementDuration(trace.cachePolicy.maxAgeNs);
+				break;
+		}
+		if (trace.persistedQueryHit) this.queryLatencyStats.persistedQueryHits++;
+		if (trace.persistedQueryRegister) this.queryLatencyStats.persistedQueryMisses++;
+		if (trace.forbiddenOperation) this.queryLatencyStats.forbiddenOperationCount++;
+		if (trace.registeredOperation) this.queryLatencyStats.registeredOperationCount++;
+		let hasError = false;
+		const errorPathStats = /* @__PURE__ */ new Set();
+		const traceNodeStats = (node, path) => {
+			if (node.error?.length) {
+				hasError = true;
+				let currPathErrorStats = this.queryLatencyStats.rootErrorStats;
+				path.toArray().forEach((subPath) => {
+					currPathErrorStats = currPathErrorStats.getChild(subPath, sizeEstimator);
+				});
+				errorPathStats.add(currPathErrorStats);
+				currPathErrorStats.errorsCount += node.error.length;
+			}
+			if (fieldExecutionWeight) {
+				const fieldName = node.originalFieldName || node.responseName;
+				if (node.parentType && fieldName && node.type && node.endTime != null && node.startTime != null && node.endTime >= node.startTime) {
+					const fieldStat = this.getTypeStat(node.parentType, sizeEstimator).getFieldStat(fieldName, node.type, sizeEstimator);
+					fieldStat.errorsCount += node.error?.length ?? 0;
+					fieldStat.observedExecutionCount++;
+					fieldStat.estimatedExecutionCount += fieldExecutionWeight;
+					fieldStat.requestsWithErrorsCount += (node.error?.length ?? 0) > 0 ? 1 : 0;
+					fieldStat.latencyCount.incrementDuration(node.endTime - node.startTime, fieldExecutionWeight);
+				}
+			}
+			return false;
+		};
+		iterateOverTrace(trace, traceNodeStats, true);
+		for (const { subgraph, path } of nonFtv1ErrorPaths) {
+			hasError = true;
+			if (path) {
+				let currPathErrorStats = this.queryLatencyStats.rootErrorStats.getChild(`service:${subgraph}`, sizeEstimator);
+				path.forEach((subPath) => {
+					if (typeof subPath === "string") currPathErrorStats = currPathErrorStats.getChild(subPath, sizeEstimator);
+				});
+				errorPathStats.add(currPathErrorStats);
+				currPathErrorStats.errorsCount += 1;
+			}
+		}
+		for (const errorPath of errorPathStats) errorPath.requestsWithErrorsCount += 1;
+		if (hasError) this.queryLatencyStats.requestsWithErrorsCount++;
+	}
+	getTypeStat(parentType, sizeEstimator) {
+		const existing = this.perTypeStat[parentType];
+		if (existing) return existing;
+		sizeEstimator.bytes += estimatedBytesForString(parentType);
+		const typeStat = new OurTypeStat();
+		this.perTypeStat[parentType] = typeStat;
+		return typeStat;
+	}
+};
+var OurQueryLatencyStats = class {
+	latencyCount = new DurationHistogram();
+	requestCount = 0;
+	requestsWithoutFieldInstrumentation = 0;
+	cacheHits = 0;
+	persistedQueryHits = 0;
+	persistedQueryMisses = 0;
+	cacheLatencyCount = new DurationHistogram();
+	rootErrorStats = new OurPathErrorStats();
+	requestsWithErrorsCount = 0;
+	publicCacheTtlCount = new DurationHistogram();
+	privateCacheTtlCount = new DurationHistogram();
+	registeredOperationCount = 0;
+	forbiddenOperationCount = 0;
+};
+var OurPathErrorStats = class OurPathErrorStats {
+	children = Object.create(null);
+	errorsCount = 0;
+	requestsWithErrorsCount = 0;
+	getChild(subPath, sizeEstimator) {
+		const existing = this.children[subPath];
+		if (existing) return existing;
+		const child = new OurPathErrorStats();
+		this.children[subPath] = child;
+		sizeEstimator.bytes += estimatedBytesForString(subPath) + 4;
+		return child;
+	}
+};
+var OurTypeStat = class {
+	perFieldStat = Object.create(null);
+	getFieldStat(fieldName, returnType, sizeEstimator) {
+		const existing = this.perFieldStat[fieldName];
+		if (existing) return existing;
+		sizeEstimator.bytes += estimatedBytesForString(fieldName) + estimatedBytesForString(returnType) + 10;
+		const fieldStat = new OurFieldStat(returnType);
+		this.perFieldStat[fieldName] = fieldStat;
+		return fieldStat;
+	}
+	ensureCountsAreIntegers() {
+		for (const fieldStat of Object.values(this.perFieldStat)) fieldStat.ensureCountsAreIntegers();
+	}
+};
+var OurFieldStat = class {
+	errorsCount = 0;
+	observedExecutionCount = 0;
+	estimatedExecutionCount = 0;
+	requestsWithErrorsCount = 0;
+	latencyCount = new DurationHistogram();
+	constructor(returnType) {
+		this.returnType = returnType;
+	}
+	ensureCountsAreIntegers() {
+		this.estimatedExecutionCount = Math.floor(this.estimatedExecutionCount);
+	}
+};
+function estimatedBytesForString(s) {
+	return 2 + Buffer.byteLength(s);
+}
+var DurationHistogram = class DurationHistogram {
+	buckets;
+	static BUCKET_COUNT = 384;
+	static EXPONENT_LOG = Math.log(1.1);
+	toArray() {
+		let bufferedZeroes = 0;
+		const outputArray = [];
+		for (const value of this.buckets) if (value === 0) bufferedZeroes++;
+		else {
+			if (bufferedZeroes === 1) outputArray.push(0);
+			else if (bufferedZeroes !== 0) outputArray.push(-bufferedZeroes);
+			outputArray.push(Math.floor(value));
+			bufferedZeroes = 0;
+		}
+		return outputArray;
+	}
+	static durationToBucket(durationNs) {
+		const log = Math.log(durationNs / 1e3);
+		const unboundedBucket = Math.ceil(log / DurationHistogram.EXPONENT_LOG);
+		return unboundedBucket <= 0 || Number.isNaN(unboundedBucket) ? 0 : unboundedBucket >= DurationHistogram.BUCKET_COUNT ? DurationHistogram.BUCKET_COUNT - 1 : unboundedBucket;
+	}
+	incrementDuration(durationNs, value = 1) {
+		this.incrementBucket(DurationHistogram.durationToBucket(durationNs), value);
+		return this;
+	}
+	incrementBucket(bucket, value = 1) {
+		if (bucket >= DurationHistogram.BUCKET_COUNT) throw Error("Bucket is out of bounds of the buckets array");
+		if (bucket >= this.buckets.length) {
+			const oldLength = this.buckets.length;
+			this.buckets.length = bucket + 1;
+			this.buckets.fill(0, oldLength);
+		}
+		this.buckets[bucket] += value;
+	}
+	combine(otherHistogram) {
+		for (let i = 0; i < otherHistogram.buckets.length; i++) this.incrementBucket(i, otherHistogram.buckets[i]);
+	}
+	constructor(options) {
+		const initSize = options?.initSize || 74;
+		const buckets = options?.buckets;
+		const arrayInitSize = Math.max(buckets?.length || 0, initSize);
+		this.buckets = Array(arrayInitSize).fill(0);
+		if (buckets) buckets.forEach((val, index) => this.buckets[index] = val);
+	}
+};
+/**
+* Iterates over the entire trace, calling `f` on each Trace.Node found. It
+* looks under the "root" node as well as any inside the query plan. If any `f`
+* returns true, it stops walking the tree.
+*
+* Each call to `f` will receive an object that implements ResponseNamePath. If
+* `includePath` is true, `f` can call `toArray()` on it to convert the
+* linked-list representation to an array of the response name (field name)
+* nodes that you navigate to get to the node (including a "service:subgraph"
+* top-level node if this is a federated trace). Note that we don't add anything
+* to the path for index (list element) nodes. This is because the only use case
+* we have (error path statistics) does not care about list indexes (it's not
+* that interesting to know that sometimes an error was at foo.3.bar and
+* sometimes foo.5.bar, vs just generally foo.bar).
+*
+* If `includePath` is false, we don't bother to build up the linked lists, and
+* calling `toArray()` will throw.
+*/
+function iterateOverTrace(trace, f, includePath) {
+	const rootPath = includePath ? new RootCollectingPathsResponseNamePath() : notCollectingPathsResponseNamePath;
+	if (trace.root) {
+		if (iterateOverTraceNode(trace.root, rootPath, f)) return;
+	}
+	if (trace.queryPlan) {
+		if (iterateOverQueryPlan(trace.queryPlan, rootPath, f)) return;
+	}
+}
+function iterateOverQueryPlan(node, rootPath, f) {
+	if (!node) return false;
+	if (node.fetch?.trace?.root && node.fetch.serviceName) return iterateOverTraceNode(node.fetch.trace.root, rootPath.child(`service:${node.fetch.serviceName}`), f);
+	if (node.flatten?.node) return iterateOverQueryPlan(node.flatten.node, rootPath, f);
+	if (node.parallel?.nodes) return node.parallel.nodes.some((node$1) => iterateOverQueryPlan(node$1, rootPath, f));
+	if (node.sequence?.nodes) return node.sequence.nodes.some((node$1) => iterateOverQueryPlan(node$1, rootPath, f));
+	return false;
+}
+function iterateOverTraceNode(node, path, f) {
+	if (f(node, path)) return true;
+	return node.child?.some((child) => {
+		return iterateOverTraceNode(child, child.responseName ? path.child(child.responseName) : path, f);
+	}) ?? false;
+}
+const notCollectingPathsResponseNamePath = {
+	toArray() {
+		throw Error("not collecting paths!");
+	},
+	child() {
+		return this;
+	}
+};
+var RootCollectingPathsResponseNamePath = class {
+	toArray() {
+		return [];
+	}
+	child(responseName) {
+		return new ChildCollectingPathsResponseNamePath(responseName, this);
+	}
+};
+var ChildCollectingPathsResponseNamePath = class ChildCollectingPathsResponseNamePath {
+	constructor(responseName, prev) {
+		this.responseName = responseName;
+		this.prev = prev;
+	}
+	toArray() {
+		const out = [];
+		let curr = this;
+		while (curr instanceof ChildCollectingPathsResponseNamePath) {
+			out.push(curr.responseName);
+			curr = curr.prev;
+		}
+		return out.reverse();
+	}
+	child(responseName) {
+		return new ChildCollectingPathsResponseNamePath(responseName, this);
+	}
+};
+
+//#endregion
+export { OurReport };

package/package.json

@@ -1,20 +1,8 @@
 {
   "name": "@graphql-yoga/plugin-apollo-usage-report",
-  "version": "0.13.0",
+  "version": "0.13.1-alpha-20260116132831-dc9fc0ad2f1ad6ee99bc438c173cf8496ae505a7",
+  "type": "module",
   "description": "Apollo's GraphOS usage report plugin for GraphQL Yoga.",
-  "peerDependencies": {
-    "graphql": "^15.2.0 || ^16.0.0",
-    "graphql-yoga": "^5.18.0"
-  },
-  "dependencies": {
-    "@apollo/server-gateway-interface": "^2.0.0",
-    "@apollo/usage-reporting-protobuf": "^4.1.1",
-    "@apollo/utils.usagereporting": "^2.1.0",
-    "@graphql-tools/utils": "^10.11.0",
-    "@whatwg-node/promise-helpers": "^1.3.2",
-    "tslib": "^2.8.1",
-    "@graphql-yoga/plugin-apollo-inline-trace": "^3.18.0"
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/graphql-hive/graphql-yoga.git",
@@ -25,28 +13,65 @@
   "engines": {
     "node": ">=18.0.0"
   },
-  "main": "cjs/index.js",
-  "module": "esm/index.js",
-  "typings": "typings/index.d.ts",
-  "typescript": {
-    "definition": "typings/index.d.ts"
-  },
-  "type": "module",
+  "main": "dist/index.cjs",
+  "typings": "dist/index.d.mts",
+  "module": "dist/index.mjs",
   "exports": {
     ".": {
       "require": {
-        "types": "./typings/index.d.cts",
-        "default": "./cjs/index.js"
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
       },
       "import": {
-        "types": "./typings/index.d.ts",
-        "default": "./esm/index.js"
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
       },
       "default": {
-        "types": "./typings/index.d.ts",
-        "default": "./esm/index.js"
+        "types": "./dist/index.d.mts",
+        "default": "./dist/index.mjs"
       }
     },
     "./package.json": "./package.json"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "check": "tsc --pretty --noEmit",
+    "watch": "tsdown --watch"
+  },
+  "peerDependencies": {
+    "@envelop/core": "workspace:^",
+    "graphql": "^15.2.0 || ^16.0.0",
+    "graphql-yoga": "workspace:^"
+  },
+  "dependencies": {
+    "@apollo/server-gateway-interface": "^2.0.0",
+    "@apollo/usage-reporting-protobuf": "^4.1.1",
+    "@apollo/utils.usagereporting": "^2.1.0",
+    "@graphql-tools/utils": "^10.11.0",
+    "@graphql-yoga/logger": "workspace:^",
+    "@graphql-yoga/plugin-apollo-inline-trace": "workspace:^",
+    "@whatwg-node/promise-helpers": "^1.3.2",
+    "tslib": "^2.8.1"
+  },
+  "devDependencies": {
+    "@envelop/core": "workspace:^",
+    "@envelop/on-resolve": "workspace:^",
+    "@whatwg-node/fetch": "^0.10.6",
+    "graphql": "16.12.0",
+    "graphql-yoga": "workspace:*",
+    "tsdown": "^0.20.0-beta.1"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "buildOptions": {
+    "input": "./src/index.ts"
+  },
+  "typescript": {
+    "definition": "dist/index.d.mts"
   }
-}
+}

package/LICENSE

@@ -1,23 +0,0 @@
-MIT License
-
-Copyright (c) 2018-2020 Graphcool
-Copyright (c) 2020-2021 Prisma
-Copyright (c) 2021- The Guild
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.