@logtape/graphql-yoga 2.3.0-dev.0

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright 2024–2026 Hong Minhee
+
+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.

package/README.md

@@ -0,0 +1,106 @@
+<!-- deno-fmt-ignore-file -->
+
+@logtape/graphql-yoga
+=====================
+
+[![JSR][JSR badge]][JSR]
+[![npm][npm badge]][npm]
+
+*@logtape/graphql-yoga* is a [GraphQL Yoga] logger adapter that allows you to
+use [LogTape] as Yoga's logging backend.  This routes Yoga's internal debug,
+info, warning, and error logs through LogTape's structured logging system.
+
+[JSR badge]: https://jsr.io/badges/@logtape/graphql-yoga
+[JSR]: https://jsr.io/@logtape/graphql-yoga
+[npm badge]: https://img.shields.io/npm/v/@logtape/graphql-yoga?logo=npm
+[npm]: https://www.npmjs.com/package/@logtape/graphql-yoga
+[GraphQL Yoga]: https://the-guild.dev/graphql/yoga-server
+[LogTape]: https://logtape.org/
+
+
+Installation
+------------
+
+~~~~ sh
+deno add jsr:@logtape/graphql-yoga  # for Deno
+npm  add     @logtape/graphql-yoga  # for npm
+pnpm add     @logtape/graphql-yoga  # for pnpm
+yarn add     @logtape/graphql-yoga  # for Yarn
+bun  add     @logtape/graphql-yoga  # for Bun
+~~~~
+
+
+Usage
+-----
+
+~~~~ typescript
+import { configure, getConsoleSink } from "@logtape/logtape";
+import { getYogaLogger } from "@logtape/graphql-yoga";
+import { createSchema, createYoga } from "graphql-yoga";
+
+await configure({
+  sinks: { console: getConsoleSink() },
+  loggers: [
+    { category: ["graphql-yoga"], sinks: ["console"], lowestLevel: "debug" }
+  ],
+});
+
+const yoga = createYoga({
+  schema: createSchema({
+    typeDefs: /* GraphQL */ `
+      type Query {
+        hello: String!
+      }
+    `,
+    resolvers: {
+      Query: {
+        hello: () => "world",
+      },
+    },
+  }),
+  logging: getYogaLogger(),
+});
+~~~~
+
+
+Custom category
+---------------
+
+You can specify a custom category for the logger:
+
+~~~~ typescript
+const yoga = createYoga({
+  schema,
+  logging: getYogaLogger({
+    category: ["myapp", "graphql"],
+  }),
+});
+~~~~
+
+
+Custom log levels
+-----------------
+
+Yoga exposes `debug`, `info`, `warn`, and `error` logger methods.  By default,
+these map to LogTape's `debug`, `info`, `warning`, and `error` levels.  You can
+customize the mapping:
+
+~~~~ typescript
+const yoga = createYoga({
+  schema,
+  logging: getYogaLogger({
+    levelsMap: {
+      debug: "trace",
+      warn: "error",
+    },
+  }),
+});
+~~~~
+
+
+Docs
+----
+
+The docs of this package is available at
+<https://logtape.org/manual/integrations#graphql-yoga>.
+For the API references, see <https://jsr.io/@logtape/graphql-yoga/doc>.

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,30 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+Object.defineProperty(exports, '__toESM', {
+  enumerable: true,
+  get: function () {
+    return __toESM;
+  }
+});

package/dist/mod.cjs

@@ -0,0 +1,94 @@
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const __logtape_logtape = require_rolldown_runtime.__toESM(require("@logtape/logtape"));
+
+//#region src/mod.ts
+const defaultLevelsMap = {
+	debug: "debug",
+	info: "info",
+	warn: "warning",
+	error: "error"
+};
+/**
+* Creates a GraphQL Yoga-compatible logger that wraps LogTape.
+*
+* @example Basic usage
+* ```typescript
+* import { configure } from "@logtape/logtape";
+* import { getYogaLogger } from "@logtape/graphql-yoga";
+* import { createYoga } from "graphql-yoga";
+*
+* await configure({
+*   // ... LogTape configuration
+* });
+*
+* const yoga = createYoga({
+*   schema,
+*   logging: getYogaLogger(),
+* });
+* ```
+*
+* @example With custom category and level mapping
+* ```typescript
+* const yoga = createYoga({
+*   schema,
+*   logging: getYogaLogger({
+*     category: ["myapp", "graphql"],
+*     levelsMap: { warn: "error" },
+*   }),
+* });
+* ```
+*
+* @param options Configuration options for the logger.
+* @returns A GraphQL Yoga-compatible logger wrapping LogTape.
+* @since 2.3.0
+*/
+function getYogaLogger(options = {}) {
+	const category = normalizeCategory(options.category ?? ["graphql-yoga"]);
+	const logger = (0, __logtape_logtape.getLogger)(category);
+	const levelsMap = {
+		...defaultLevelsMap,
+		...options.levelsMap
+	};
+	return {
+		debug: (...args) => logYogaArgs(logger, levelsMap.debug, args),
+		info: (...args) => logYogaArgs(logger, levelsMap.info, args),
+		warn: (...args) => logYogaArgs(logger, levelsMap.warn, args),
+		error: (...args) => logYogaArgs(logger, levelsMap.error, args)
+	};
+}
+function normalizeCategory(category) {
+	return typeof category === "string" ? [category] : category;
+}
+function logYogaArgs(logger, level, args) {
+	const [first, ...rest] = args;
+	const properties = rest.length > 0 ? { args: rest } : void 0;
+	if (args.length < 1) logWithMessage(logger, level, "GraphQL Yoga log");
+	else if (first instanceof Error) logError(logger, level, first, properties);
+	else if (typeof first === "string") logWithMessage(logger, level, first, properties);
+	else if (args.length === 1 && isPlainRecord(first)) logWithMessage(logger, level, "{*}", first);
+	else logWithMessage(logger, level, "{*}", { args });
+}
+function logError(logger, level, error, properties) {
+	if (level === "warning" || level === "error" || level === "fatal") {
+		const logMethod = logger[level].bind(logger);
+		logMethod(error, properties);
+		return;
+	}
+	logWithMessage(logger, level, "{error.message}", {
+		...properties,
+		error
+	});
+}
+function logWithMessage(logger, level, message, properties) {
+	const logMethod = logger[level].bind(logger);
+	logMethod(message, properties);
+}
+function isPlainRecord(value) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+	if (value instanceof Error) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
+//#endregion
+exports.getYogaLogger = getYogaLogger;

package/dist/mod.d.cts

@@ -0,0 +1,84 @@
+import { LogLevel, LogLevel as LogLevel$1 } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * GraphQL Yoga log levels.
+ * @since 2.3.0
+ */
+type YogaLogLevel = "debug" | "info" | "warn" | "error";
+/**
+ * A GraphQL Yoga-compatible logger that wraps LogTape.
+ * @since 2.3.0
+ */
+interface YogaLogger {
+  /** Log at Yoga's debug level. */
+  debug(...args: readonly unknown[]): void;
+  /** Log at Yoga's info level. */
+  info(...args: readonly unknown[]): void;
+  /** Log at Yoga's warning level. */
+  warn(...args: readonly unknown[]): void;
+  /** Log at Yoga's error level. */
+  error(...args: readonly unknown[]): void;
+}
+/**
+ * Options for configuring the GraphQL Yoga LogTape logger.
+ * @since 2.3.0
+ */
+interface YogaLoggerOptions {
+  /**
+   * The LogTape category to use for logging.
+   * @default ["graphql-yoga"]
+   */
+  readonly category?: string | readonly string[];
+  /**
+   * Mapping between GraphQL Yoga log levels and LogTape log levels.
+   *
+   * By default, Yoga levels are mapped as follows:
+   *
+   * - `debug` -> `debug`
+   * - `info` -> `info`
+   * - `warn` -> `warning`
+   * - `error` -> `error`
+   */
+  readonly levelsMap?: Partial<Readonly<Record<YogaLogLevel, LogLevel$1>>>;
+}
+/**
+ * Creates a GraphQL Yoga-compatible logger that wraps LogTape.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { configure } from "@logtape/logtape";
+ * import { getYogaLogger } from "@logtape/graphql-yoga";
+ * import { createYoga } from "graphql-yoga";
+ *
+ * await configure({
+ *   // ... LogTape configuration
+ * });
+ *
+ * const yoga = createYoga({
+ *   schema,
+ *   logging: getYogaLogger(),
+ * });
+ * ```
+ *
+ * @example With custom category and level mapping
+ * ```typescript
+ * const yoga = createYoga({
+ *   schema,
+ *   logging: getYogaLogger({
+ *     category: ["myapp", "graphql"],
+ *     levelsMap: { warn: "error" },
+ *   }),
+ * });
+ * ```
+ *
+ * @param options Configuration options for the logger.
+ * @returns A GraphQL Yoga-compatible logger wrapping LogTape.
+ * @since 2.3.0
+ */
+declare function getYogaLogger(options?: YogaLoggerOptions): YogaLogger;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { LogLevel, YogaLogLevel, YogaLogger, YogaLoggerOptions, getYogaLogger };
+//# sourceMappingURL=mod.d.cts.map

package/dist/mod.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.cts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;AAYA;AAMA;AAkBA;AAAkC,KAxBtB,YAAA,GAwBsB,OAAA,GAAA,MAAA,GAAA,MAAA,GAAA,OAAA;;;;;AAiBX,UAnCN,UAAA,CAmCM;EAAO;EA4Cd,KAAA,CAAA,GAAA,IAAA,EAAA,SAAa,OAAA,EAAA,CAAA,EAAA,IAAA;EAAA;EAAA,IAAU,CAAA,GAAA,IAAA,EAAA,SAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAAsB;EAAa,IAAA,CAAA,GAAA,IAAA,EAAA,SAAA,OAAA,EAAA,CAAA,EAAA,IAAA;;;;;;;;UA7DzD,iBAAA;;;;;;;;;;;;;;;;uBAiBM,QAAQ,SAAS,OAAO,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4C7C,aAAA,WAAuB,oBAAyB"}

package/dist/mod.d.ts

@@ -0,0 +1,84 @@
+import { LogLevel, LogLevel as LogLevel$1 } from "@logtape/logtape";
+
+//#region src/mod.d.ts
+
+/**
+ * GraphQL Yoga log levels.
+ * @since 2.3.0
+ */
+type YogaLogLevel = "debug" | "info" | "warn" | "error";
+/**
+ * A GraphQL Yoga-compatible logger that wraps LogTape.
+ * @since 2.3.0
+ */
+interface YogaLogger {
+  /** Log at Yoga's debug level. */
+  debug(...args: readonly unknown[]): void;
+  /** Log at Yoga's info level. */
+  info(...args: readonly unknown[]): void;
+  /** Log at Yoga's warning level. */
+  warn(...args: readonly unknown[]): void;
+  /** Log at Yoga's error level. */
+  error(...args: readonly unknown[]): void;
+}
+/**
+ * Options for configuring the GraphQL Yoga LogTape logger.
+ * @since 2.3.0
+ */
+interface YogaLoggerOptions {
+  /**
+   * The LogTape category to use for logging.
+   * @default ["graphql-yoga"]
+   */
+  readonly category?: string | readonly string[];
+  /**
+   * Mapping between GraphQL Yoga log levels and LogTape log levels.
+   *
+   * By default, Yoga levels are mapped as follows:
+   *
+   * - `debug` -> `debug`
+   * - `info` -> `info`
+   * - `warn` -> `warning`
+   * - `error` -> `error`
+   */
+  readonly levelsMap?: Partial<Readonly<Record<YogaLogLevel, LogLevel$1>>>;
+}
+/**
+ * Creates a GraphQL Yoga-compatible logger that wraps LogTape.
+ *
+ * @example Basic usage
+ * ```typescript
+ * import { configure } from "@logtape/logtape";
+ * import { getYogaLogger } from "@logtape/graphql-yoga";
+ * import { createYoga } from "graphql-yoga";
+ *
+ * await configure({
+ *   // ... LogTape configuration
+ * });
+ *
+ * const yoga = createYoga({
+ *   schema,
+ *   logging: getYogaLogger(),
+ * });
+ * ```
+ *
+ * @example With custom category and level mapping
+ * ```typescript
+ * const yoga = createYoga({
+ *   schema,
+ *   logging: getYogaLogger({
+ *     category: ["myapp", "graphql"],
+ *     levelsMap: { warn: "error" },
+ *   }),
+ * });
+ * ```
+ *
+ * @param options Configuration options for the logger.
+ * @returns A GraphQL Yoga-compatible logger wrapping LogTape.
+ * @since 2.3.0
+ */
+declare function getYogaLogger(options?: YogaLoggerOptions): YogaLogger;
+//# sourceMappingURL=mod.d.ts.map
+//#endregion
+export { LogLevel, YogaLogLevel, YogaLogger, YogaLoggerOptions, getYogaLogger };
+//# sourceMappingURL=mod.d.ts.map

package/dist/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","names":[],"sources":["../src/mod.ts"],"sourcesContent":[],"mappings":";;;;;AAYA;AAMA;AAkBA;AAAkC,KAxBtB,YAAA,GAwBsB,OAAA,GAAA,MAAA,GAAA,MAAA,GAAA,OAAA;;;;;AAiBX,UAnCN,UAAA,CAmCM;EAAO;EA4Cd,KAAA,CAAA,GAAA,IAAA,EAAA,SAAa,OAAA,EAAA,CAAA,EAAA,IAAA;EAAA;EAAA,IAAU,CAAA,GAAA,IAAA,EAAA,SAAA,OAAA,EAAA,CAAA,EAAA,IAAA;EAAsB;EAAa,IAAA,CAAA,GAAA,IAAA,EAAA,SAAA,OAAA,EAAA,CAAA,EAAA,IAAA;;;;;;;;UA7DzD,iBAAA;;;;;;;;;;;;;;;;uBAiBM,QAAQ,SAAS,OAAO,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA4C7C,aAAA,WAAuB,oBAAyB"}

package/dist/mod.js

@@ -0,0 +1,94 @@
+import { getLogger } from "@logtape/logtape";
+
+//#region src/mod.ts
+const defaultLevelsMap = {
+	debug: "debug",
+	info: "info",
+	warn: "warning",
+	error: "error"
+};
+/**
+* Creates a GraphQL Yoga-compatible logger that wraps LogTape.
+*
+* @example Basic usage
+* ```typescript
+* import { configure } from "@logtape/logtape";
+* import { getYogaLogger } from "@logtape/graphql-yoga";
+* import { createYoga } from "graphql-yoga";
+*
+* await configure({
+*   // ... LogTape configuration
+* });
+*
+* const yoga = createYoga({
+*   schema,
+*   logging: getYogaLogger(),
+* });
+* ```
+*
+* @example With custom category and level mapping
+* ```typescript
+* const yoga = createYoga({
+*   schema,
+*   logging: getYogaLogger({
+*     category: ["myapp", "graphql"],
+*     levelsMap: { warn: "error" },
+*   }),
+* });
+* ```
+*
+* @param options Configuration options for the logger.
+* @returns A GraphQL Yoga-compatible logger wrapping LogTape.
+* @since 2.3.0
+*/
+function getYogaLogger(options = {}) {
+	const category = normalizeCategory(options.category ?? ["graphql-yoga"]);
+	const logger = getLogger(category);
+	const levelsMap = {
+		...defaultLevelsMap,
+		...options.levelsMap
+	};
+	return {
+		debug: (...args) => logYogaArgs(logger, levelsMap.debug, args),
+		info: (...args) => logYogaArgs(logger, levelsMap.info, args),
+		warn: (...args) => logYogaArgs(logger, levelsMap.warn, args),
+		error: (...args) => logYogaArgs(logger, levelsMap.error, args)
+	};
+}
+function normalizeCategory(category) {
+	return typeof category === "string" ? [category] : category;
+}
+function logYogaArgs(logger, level, args) {
+	const [first, ...rest] = args;
+	const properties = rest.length > 0 ? { args: rest } : void 0;
+	if (args.length < 1) logWithMessage(logger, level, "GraphQL Yoga log");
+	else if (first instanceof Error) logError(logger, level, first, properties);
+	else if (typeof first === "string") logWithMessage(logger, level, first, properties);
+	else if (args.length === 1 && isPlainRecord(first)) logWithMessage(logger, level, "{*}", first);
+	else logWithMessage(logger, level, "{*}", { args });
+}
+function logError(logger, level, error, properties) {
+	if (level === "warning" || level === "error" || level === "fatal") {
+		const logMethod = logger[level].bind(logger);
+		logMethod(error, properties);
+		return;
+	}
+	logWithMessage(logger, level, "{error.message}", {
+		...properties,
+		error
+	});
+}
+function logWithMessage(logger, level, message, properties) {
+	const logMethod = logger[level].bind(logger);
+	logMethod(message, properties);
+}
+function isPlainRecord(value) {
+	if (value == null || typeof value !== "object" || Array.isArray(value)) return false;
+	if (value instanceof Error) return false;
+	const prototype = Object.getPrototypeOf(value);
+	return prototype === Object.prototype || prototype === null;
+}
+
+//#endregion
+export { getYogaLogger };
+//# sourceMappingURL=mod.js.map

package/dist/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","names":["defaultLevelsMap: Readonly<Record<YogaLogLevel, LogLevel>>","options: YogaLoggerOptions","category: string | readonly string[]","logger: LogTapeLogger","level: LogLevel","args: readonly unknown[]","error: Error","properties?: Record<string, unknown>","message: string","value: unknown"],"sources":["../src/mod.ts"],"sourcesContent":["import {\n  getLogger as getLogTapeLogger,\n  type Logger as LogTapeLogger,\n  type LogLevel,\n} from \"@logtape/logtape\";\n\nexport type { LogLevel } from \"@logtape/logtape\";\n\n/**\n * GraphQL Yoga log levels.\n * @since 2.3.0\n */\nexport type YogaLogLevel = \"debug\" | \"info\" | \"warn\" | \"error\";\n\n/**\n * A GraphQL Yoga-compatible logger that wraps LogTape.\n * @since 2.3.0\n */\nexport interface YogaLogger {\n  /** Log at Yoga's debug level. */\n  debug(...args: readonly unknown[]): void;\n\n  /** Log at Yoga's info level. */\n  info(...args: readonly unknown[]): void;\n\n  /** Log at Yoga's warning level. */\n  warn(...args: readonly unknown[]): void;\n\n  /** Log at Yoga's error level. */\n  error(...args: readonly unknown[]): void;\n}\n\n/**\n * Options for configuring the GraphQL Yoga LogTape logger.\n * @since 2.3.0\n */\nexport interface YogaLoggerOptions {\n  /**\n   * The LogTape category to use for logging.\n   * @default [\"graphql-yoga\"]\n   */\n  readonly category?: string | readonly string[];\n\n  /**\n   * Mapping between GraphQL Yoga log levels and LogTape log levels.\n   *\n   * By default, Yoga levels are mapped as follows:\n   *\n   * - `debug` -> `debug`\n   * - `info` -> `info`\n   * - `warn` -> `warning`\n   * - `error` -> `error`\n   */\n  readonly levelsMap?: Partial<Readonly<Record<YogaLogLevel, LogLevel>>>;\n}\n\nconst defaultLevelsMap: Readonly<Record<YogaLogLevel, LogLevel>> = {\n  debug: \"debug\",\n  info: \"info\",\n  warn: \"warning\",\n  error: \"error\",\n};\n\n/**\n * Creates a GraphQL Yoga-compatible logger that wraps LogTape.\n *\n * @example Basic usage\n * ```typescript\n * import { configure } from \"@logtape/logtape\";\n * import { getYogaLogger } from \"@logtape/graphql-yoga\";\n * import { createYoga } from \"graphql-yoga\";\n *\n * await configure({\n *   // ... LogTape configuration\n * });\n *\n * const yoga = createYoga({\n *   schema,\n *   logging: getYogaLogger(),\n * });\n * ```\n *\n * @example With custom category and level mapping\n * ```typescript\n * const yoga = createYoga({\n *   schema,\n *   logging: getYogaLogger({\n *     category: [\"myapp\", \"graphql\"],\n *     levelsMap: { warn: \"error\" },\n *   }),\n * });\n * ```\n *\n * @param options Configuration options for the logger.\n * @returns A GraphQL Yoga-compatible logger wrapping LogTape.\n * @since 2.3.0\n */\nexport function getYogaLogger(options: YogaLoggerOptions = {}): YogaLogger {\n  const category = normalizeCategory(options.category ?? [\"graphql-yoga\"]);\n  const logger = getLogTapeLogger(category);\n  const levelsMap = { ...defaultLevelsMap, ...options.levelsMap };\n\n  return {\n    debug: (...args) => logYogaArgs(logger, levelsMap.debug, args),\n    info: (...args) => logYogaArgs(logger, levelsMap.info, args),\n    warn: (...args) => logYogaArgs(logger, levelsMap.warn, args),\n    error: (...args) => logYogaArgs(logger, levelsMap.error, args),\n  };\n}\n\nfunction normalizeCategory(\n  category: string | readonly string[],\n): readonly string[] {\n  return typeof category === \"string\" ? [category] : category;\n}\n\nfunction logYogaArgs(\n  logger: LogTapeLogger,\n  level: LogLevel,\n  args: readonly unknown[],\n): void {\n  const [first, ...rest] = args;\n  const properties = rest.length > 0 ? { args: rest } : undefined;\n\n  if (args.length < 1) {\n    logWithMessage(logger, level, \"GraphQL Yoga log\");\n  } else if (first instanceof Error) {\n    logError(logger, level, first, properties);\n  } else if (typeof first === \"string\") {\n    logWithMessage(logger, level, first, properties);\n  } else if (args.length === 1 && isPlainRecord(first)) {\n    logWithMessage(logger, level, \"{*}\", first);\n  } else {\n    logWithMessage(logger, level, \"{*}\", { args });\n  }\n}\n\nfunction logError(\n  logger: LogTapeLogger,\n  level: LogLevel,\n  error: Error,\n  properties?: Record<string, unknown>,\n): void {\n  if (level === \"warning\" || level === \"error\" || level === \"fatal\") {\n    const logMethod = logger[level].bind(logger) as (\n      error: Error,\n      properties?: Record<string, unknown>,\n    ) => void;\n    logMethod(error, properties);\n    return;\n  }\n\n  logWithMessage(logger, level, \"{error.message}\", {\n    ...properties,\n    error,\n  });\n}\n\nfunction logWithMessage(\n  logger: LogTapeLogger,\n  level: LogLevel,\n  message: string,\n  properties?: Record<string, unknown>,\n): void {\n  const logMethod = logger[level].bind(logger) as (\n    message: string,\n    properties?: Record<string, unknown>,\n  ) => void;\n  logMethod(message, properties);\n}\n\nfunction isPlainRecord(value: unknown): value is Record<string, unknown> {\n  if (value == null || typeof value !== \"object\" || Array.isArray(value)) {\n    return false;\n  }\n  if (value instanceof Error) return false;\n\n  const prototype = Object.getPrototypeOf(value);\n  return prototype === Object.prototype || prototype === null;\n}\n"],"mappings":";;;AAwDA,MAAMA,mBAA6D;CACjE,OAAO;CACP,MAAM;CACN,MAAM;CACN,OAAO;AACR;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAoCD,SAAgB,cAAcC,UAA6B,CAAE,GAAc;CACzE,MAAM,WAAW,kBAAkB,QAAQ,YAAY,CAAC,cAAe,EAAC;CACxE,MAAM,SAAS,UAAiB,SAAS;CACzC,MAAM,YAAY;EAAE,GAAG;EAAkB,GAAG,QAAQ;CAAW;AAE/D,QAAO;EACL,OAAO,CAAC,GAAG,SAAS,YAAY,QAAQ,UAAU,OAAO,KAAK;EAC9D,MAAM,CAAC,GAAG,SAAS,YAAY,QAAQ,UAAU,MAAM,KAAK;EAC5D,MAAM,CAAC,GAAG,SAAS,YAAY,QAAQ,UAAU,MAAM,KAAK;EAC5D,OAAO,CAAC,GAAG,SAAS,YAAY,QAAQ,UAAU,OAAO,KAAK;CAC/D;AACF;AAED,SAAS,kBACPC,UACmB;AACnB,eAAc,aAAa,WAAW,CAAC,QAAS,IAAG;AACpD;AAED,SAAS,YACPC,QACAC,OACAC,MACM;CACN,MAAM,CAAC,OAAO,GAAG,KAAK,GAAG;CACzB,MAAM,aAAa,KAAK,SAAS,IAAI,EAAE,MAAM,KAAM;AAEnD,KAAI,KAAK,SAAS,EAChB,gBAAe,QAAQ,OAAO,mBAAmB;UACxC,iBAAiB,MAC1B,UAAS,QAAQ,OAAO,OAAO,WAAW;iBAC1B,UAAU,SAC1B,gBAAe,QAAQ,OAAO,OAAO,WAAW;UACvC,KAAK,WAAW,KAAK,cAAc,MAAM,CAClD,gBAAe,QAAQ,OAAO,OAAO,MAAM;KAE3C,gBAAe,QAAQ,OAAO,OAAO,EAAE,KAAM,EAAC;AAEjD;AAED,SAAS,SACPF,QACAC,OACAE,OACAC,YACM;AACN,KAAI,UAAU,aAAa,UAAU,WAAW,UAAU,SAAS;EACjE,MAAM,YAAY,OAAO,OAAO,KAAK,OAAO;AAI5C,YAAU,OAAO,WAAW;AAC5B;CACD;AAED,gBAAe,QAAQ,OAAO,mBAAmB;EAC/C,GAAG;EACH;CACD,EAAC;AACH;AAED,SAAS,eACPJ,QACAC,OACAI,SACAD,YACM;CACN,MAAM,YAAY,OAAO,OAAO,KAAK,OAAO;AAI5C,WAAU,SAAS,WAAW;AAC/B;AAED,SAAS,cAAcE,OAAkD;AACvE,KAAI,SAAS,eAAe,UAAU,YAAY,MAAM,QAAQ,MAAM,CACpE,QAAO;AAET,KAAI,iBAAiB,MAAO,QAAO;CAEnC,MAAM,YAAY,OAAO,eAAe,MAAM;AAC9C,QAAO,cAAc,OAAO,aAAa,cAAc;AACxD"}

package/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@logtape/graphql-yoga",
+  "version": "2.3.0-dev.0",
+  "description": "GraphQL Yoga adapter for LogTape logging library",
+  "keywords": [
+    "logging",
+    "log",
+    "logger",
+    "graphql",
+    "graphql-yoga",
+    "yoga",
+    "adapter",
+    "logtape"
+  ],
+  "license": "MIT",
+  "author": {
+    "name": "Hong Minhee",
+    "email": "hong@minhee.org",
+    "url": "https://hongminhee.org/"
+  },
+  "homepage": "https://logtape.org/",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dahlia/logtape.git",
+    "directory": "packages/graphql-yoga/"
+  },
+  "bugs": {
+    "url": "https://github.com/dahlia/logtape/issues"
+  },
+  "funding": [
+    "https://github.com/sponsors/dahlia"
+  ],
+  "type": "module",
+  "module": "./dist/mod.js",
+  "main": "./dist/mod.cjs",
+  "types": "./dist/mod.d.ts",
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/mod.d.ts",
+        "require": "./dist/mod.d.cts"
+      },
+      "import": "./dist/mod.js",
+      "require": "./dist/mod.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "files": [
+    "dist/"
+  ],
+  "peerDependencies": {
+    "@logtape/logtape": "^2.3.0"
+  },
+  "devDependencies": {
+    "@alinea/suite": "^0.6.3",
+    "@std/assert": "npm:@jsr/std__assert@^1.0.13",
+    "graphql": "^16.14.2",
+    "graphql-yoga": "^5.21.2",
+    "tsdown": "^0.12.7",
+    "typescript": "^5.8.3"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "prepublish": "tsdown",
+    "test": "tsdown && node --experimental-transform-types --test",
+    "test:bun": "tsdown && bun test",
+    "test:deno": "deno test --allow-env --allow-sys --allow-net",
+    "test-all": "tsdown && node --experimental-transform-types --test && bun test && deno test"
+  }
+}