naystack 1.1.11 → 1.1.12-beta.1

package/dist/graphql/index.d.mts

@@ -1,23 +1,7 @@
-import { ApolloServerPlugin } from '@apollo/server';
-import { NextRequest } from 'next/server';
-import { AuthChecker, NonEmptyArray } from 'type-graphql';
-
-declare function initGraphQLServer({ authChecker, resolvers, plugins, refreshKey, signingKey, }: {
-    authChecker?: AuthChecker<any>;
-    resolvers: NonEmptyArray<Function>;
-    plugins?: ApolloServerPlugin[];
-    refreshKey: string;
-    signingKey: string;
-}): Promise<{
-    GET: (request: NextRequest) => Promise<Response>;
-    POST: (request: NextRequest) => Promise<Response>;
-}>;
-
-interface Context {
-    userId: number | null;
-}
-interface AuthorizedContext {
-    userId: number;
-}
-
-export { type AuthorizedContext, type Context, initGraphQLServer };
+export { initGraphQLServer } from './init.mjs';
+export { AuthorizedContext, Context } from './types.mjs';
+export { FieldLibrary, QueryLibrary, field, query } from './utils.mjs';
+import '@apollo/server';
+import 'next/server';
+import 'type-graphql';
+import 'node:vm';

package/dist/graphql/index.d.ts

@@ -1,23 +1,7 @@
-import { ApolloServerPlugin } from '@apollo/server';
-import { NextRequest } from 'next/server';
-import { AuthChecker, NonEmptyArray } from 'type-graphql';
-
-declare function initGraphQLServer({ authChecker, resolvers, plugins, refreshKey, signingKey, }: {
-    authChecker?: AuthChecker<any>;
-    resolvers: NonEmptyArray<Function>;
-    plugins?: ApolloServerPlugin[];
-    refreshKey: string;
-    signingKey: string;
-}): Promise<{
-    GET: (request: NextRequest) => Promise<Response>;
-    POST: (request: NextRequest) => Promise<Response>;
-}>;
-
-interface Context {
-    userId: number | null;
-}
-interface AuthorizedContext {
-    userId: number;
-}
-
-export { type AuthorizedContext, type Context, initGraphQLServer };
+export { initGraphQLServer } from './init.js';
+export { AuthorizedContext, Context } from './types.js';
+export { FieldLibrary, QueryLibrary, field, query } from './utils.js';
+import '@apollo/server';
+import 'next/server';
+import 'type-graphql';
+import 'node:vm';

package/dist/graphql/init.cjs.js

@@ -0,0 +1,124 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/graphql/init.ts
+var init_exports = {};
+__export(init_exports, {
+  initGraphQLServer: () => initGraphQLServer
+});
+module.exports = __toCommonJS(init_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_server3 = require("@apollo/server");
+var import_default = require("@apollo/server/plugin/landingPage/default");
+var import_next = require("@as-integrations/next");
+var import_type_graphql = require("type-graphql");
+
+// src/graphql/context.ts
+var import_jsonwebtoken2 = require("jsonwebtoken");
+
+// src/auth/email/token.ts
+var import_bcryptjs = require("bcryptjs");
+var import_jsonwebtoken = require("jsonwebtoken");
+var import_server = require("next/server");
+function getUserIdFromRefreshToken(refreshKey, refreshToken) {
+  if (refreshToken)
+    try {
+      const decoded = (0, import_jsonwebtoken.verify)(refreshToken, refreshKey);
+      if (typeof decoded !== "string" && typeof decoded.id === "number")
+        return decoded.id;
+    } catch (e) {
+      if (!(e instanceof import_jsonwebtoken.JsonWebTokenError)) console.error(e, "errors");
+      return null;
+    }
+  return null;
+}
+
+// src/auth/utils/errors.ts
+var import_server2 = require("next/server");
+function handleError(status, message, onError) {
+  const res = onError?.({ status, message });
+  if (res) return res;
+  return new import_server2.NextResponse(message, { status });
+}
+
+// src/graphql/context.ts
+var getContext = (refreshKey, signingKey) => async (req) => {
+  const bearer = req.headers.get("authorization");
+  const isMobile = req.headers.get("x-platform-is-mobile");
+  if (!bearer) {
+    if (isMobile) return { userId: null };
+    const refresh = req.cookies.get("refresh")?.value;
+    const userId = getUserIdFromRefreshToken(refreshKey, refresh);
+    if (userId) return { userId, onlyQuery: true };
+    return { userId: null };
+  }
+  const token = bearer.slice(7);
+  try {
+    const res = (0, import_jsonwebtoken2.verify)(token, signingKey);
+    return { userId: typeof res !== "string" ? res.id : null };
+  } catch {
+    if (isMobile) return handleError(401, "Refresh token is invalid.");
+  }
+  return { userId: null };
+};
+
+// src/graphql/init.ts
+async function initGraphQLServer({
+  authChecker,
+  resolvers,
+  plugins,
+  refreshKey,
+  signingKey
+}) {
+  const { typeDefs, resolvers: builtResolvers } = await (0, import_type_graphql.buildTypeDefsAndResolvers)({
+    validate: true,
+    authChecker,
+    resolvers
+  });
+  const server = new import_server3.ApolloServer({
+    typeDefs,
+    resolvers: builtResolvers,
+    plugins: [
+      process.env.NODE_ENV === "production" ? (0, import_default.ApolloServerPluginLandingPageProductionDefault)() : (0, import_default.ApolloServerPluginLandingPageLocalDefault)(),
+      {
+        async requestDidStart({ request, contextValue }) {
+          if (
+            // eslint-disable-next-line
+            contextValue.onlyQuery && !request.query?.startsWith("query")
+          )
+            contextValue.userId = null;
+        }
+      },
+      ...plugins || []
+    ],
+    introspection: process.env.NODE_ENV !== "production",
+    status400ForVariableCoercionErrors: true
+  });
+  const handler = (0, import_next.startServerAndCreateNextHandler)(server, {
+    context: getContext(refreshKey, signingKey)
+  });
+  return {
+    GET: (request) => handler(request),
+    POST: (request) => handler(request)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  initGraphQLServer
+});

package/dist/graphql/init.d.mts

@@ -0,0 +1,16 @@
+import { ApolloServerPlugin } from '@apollo/server';
+import { NextRequest } from 'next/server';
+import { AuthChecker, NonEmptyArray } from 'type-graphql';
+
+declare function initGraphQLServer({ authChecker, resolvers, plugins, refreshKey, signingKey, }: {
+    authChecker?: AuthChecker<any>;
+    resolvers: NonEmptyArray<Function>;
+    plugins?: ApolloServerPlugin[];
+    refreshKey: string;
+    signingKey: string;
+}): Promise<{
+    GET: (request: NextRequest) => Promise<Response>;
+    POST: (request: NextRequest) => Promise<Response>;
+}>;
+
+export { initGraphQLServer };

package/dist/graphql/init.d.ts

@@ -0,0 +1,16 @@
+import { ApolloServerPlugin } from '@apollo/server';
+import { NextRequest } from 'next/server';
+import { AuthChecker, NonEmptyArray } from 'type-graphql';
+
+declare function initGraphQLServer({ authChecker, resolvers, plugins, refreshKey, signingKey, }: {
+    authChecker?: AuthChecker<any>;
+    resolvers: NonEmptyArray<Function>;
+    plugins?: ApolloServerPlugin[];
+    refreshKey: string;
+    signingKey: string;
+}): Promise<{
+    GET: (request: NextRequest) => Promise<Response>;
+    POST: (request: NextRequest) => Promise<Response>;
+}>;
+
+export { initGraphQLServer };

package/dist/graphql/init.esm.js

@@ -0,0 +1,104 @@
+// src/graphql/init.ts
+import "reflect-metadata";
+import { ApolloServer } from "@apollo/server";
+import {
+  ApolloServerPluginLandingPageLocalDefault,
+  ApolloServerPluginLandingPageProductionDefault
+} from "@apollo/server/plugin/landingPage/default";
+import { startServerAndCreateNextHandler } from "@as-integrations/next";
+import {
+  buildTypeDefsAndResolvers
+} from "type-graphql";
+
+// src/graphql/context.ts
+import { verify as verify2 } from "jsonwebtoken";
+
+// src/auth/email/token.ts
+import { compare } from "bcryptjs";
+import { JsonWebTokenError, sign, verify } from "jsonwebtoken";
+import { NextResponse } from "next/server";
+function getUserIdFromRefreshToken(refreshKey, refreshToken) {
+  if (refreshToken)
+    try {
+      const decoded = verify(refreshToken, refreshKey);
+      if (typeof decoded !== "string" && typeof decoded.id === "number")
+        return decoded.id;
+    } catch (e) {
+      if (!(e instanceof JsonWebTokenError)) console.error(e, "errors");
+      return null;
+    }
+  return null;
+}
+
+// src/auth/utils/errors.ts
+import { NextResponse as NextResponse2 } from "next/server";
+function handleError(status, message, onError) {
+  const res = onError?.({ status, message });
+  if (res) return res;
+  return new NextResponse2(message, { status });
+}
+
+// src/graphql/context.ts
+var getContext = (refreshKey, signingKey) => async (req) => {
+  const bearer = req.headers.get("authorization");
+  const isMobile = req.headers.get("x-platform-is-mobile");
+  if (!bearer) {
+    if (isMobile) return { userId: null };
+    const refresh = req.cookies.get("refresh")?.value;
+    const userId = getUserIdFromRefreshToken(refreshKey, refresh);
+    if (userId) return { userId, onlyQuery: true };
+    return { userId: null };
+  }
+  const token = bearer.slice(7);
+  try {
+    const res = verify2(token, signingKey);
+    return { userId: typeof res !== "string" ? res.id : null };
+  } catch {
+    if (isMobile) return handleError(401, "Refresh token is invalid.");
+  }
+  return { userId: null };
+};
+
+// src/graphql/init.ts
+async function initGraphQLServer({
+  authChecker,
+  resolvers,
+  plugins,
+  refreshKey,
+  signingKey
+}) {
+  const { typeDefs, resolvers: builtResolvers } = await buildTypeDefsAndResolvers({
+    validate: true,
+    authChecker,
+    resolvers
+  });
+  const server = new ApolloServer({
+    typeDefs,
+    resolvers: builtResolvers,
+    plugins: [
+      process.env.NODE_ENV === "production" ? ApolloServerPluginLandingPageProductionDefault() : ApolloServerPluginLandingPageLocalDefault(),
+      {
+        async requestDidStart({ request, contextValue }) {
+          if (
+            // eslint-disable-next-line
+            contextValue.onlyQuery && !request.query?.startsWith("query")
+          )
+            contextValue.userId = null;
+        }
+      },
+      ...plugins || []
+    ],
+    introspection: process.env.NODE_ENV !== "production",
+    status400ForVariableCoercionErrors: true
+  });
+  const handler = startServerAndCreateNextHandler(server, {
+    context: getContext(refreshKey, signingKey)
+  });
+  return {
+    GET: (request) => handler(request),
+    POST: (request) => handler(request)
+  };
+}
+export {
+  initGraphQLServer
+};

package/dist/graphql/types.cjs.js

@@ -0,0 +1,18 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/graphql/types.ts
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/dist/graphql/types.d.mts

@@ -0,0 +1,8 @@
+interface Context {
+    userId: number | null;
+}
+interface AuthorizedContext {
+    userId: number;
+}
+
+export type { AuthorizedContext, Context };

package/dist/graphql/types.d.ts

@@ -0,0 +1,8 @@
+interface Context {
+    userId: number | null;
+}
+interface AuthorizedContext {
+    userId: number;
+}
+
+export type { AuthorizedContext, Context };

package/dist/graphql/utils.cjs.js

@@ -0,0 +1,134 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/graphql/utils.ts
+var utils_exports = {};
+__export(utils_exports, {
+  FieldLibrary: () => FieldLibrary,
+  QueryLibrary: () => QueryLibrary,
+  field: () => field,
+  query: () => query
+});
+module.exports = __toCommonJS(utils_exports);
+var import_type_graphql = require("type-graphql");
+function query(fn, options) {
+  return { ...options, fn };
+}
+function field(fn, options) {
+  return { ...options, fn };
+}
+function QueryLibrary(queries) {
+  let GeneratedResolver = class {
+  };
+  GeneratedResolver = __decorateClass([
+    (0, import_type_graphql.Resolver)()
+  ], GeneratedResolver);
+  for (const key in queries) {
+    const def = queries[key];
+    if (!def) continue;
+    Object.defineProperty(GeneratedResolver.prototype, key, {
+      // eslint-disable-next-line
+      value: async function(ctx, data) {
+        return def.fn(ctx, data);
+      },
+      writable: false
+    });
+    const descriptor = Object.getOwnPropertyDescriptor(
+      GeneratedResolver.prototype,
+      key
+    );
+    if (def.mutation) {
+      (0, import_type_graphql.Mutation)(() => def.output, def.outputOptions)(
+        GeneratedResolver.prototype,
+        key,
+        descriptor
+      );
+    } else {
+      (0, import_type_graphql.Query)(() => def.output, def.outputOptions)(
+        GeneratedResolver.prototype,
+        key,
+        descriptor
+      );
+    }
+    (0, import_type_graphql.Ctx)()(GeneratedResolver.prototype, key, 0);
+    if (def.input) {
+      (0, import_type_graphql.Arg)("input", () => def.input || String, def.inputOptions)(
+        GeneratedResolver.prototype,
+        key,
+        1
+      );
+    }
+  }
+  return GeneratedResolver;
+}
+function FieldLibrary(type, queries) {
+  let GeneratedResolver = class {
+  };
+  GeneratedResolver = __decorateClass([
+    (0, import_type_graphql.Resolver)(() => type)
+  ], GeneratedResolver);
+  for (const key in queries) {
+    const def = queries[key];
+    if (!def) continue;
+    Object.defineProperty(GeneratedResolver.prototype, key, {
+      // eslint-disable-next-line
+      value: async function(root, ctx, input) {
+        return def.fn(root, ctx, input);
+      },
+      writable: false
+    });
+    const descriptor = Object.getOwnPropertyDescriptor(
+      GeneratedResolver.prototype,
+      key
+    );
+    if (def.authorized) {
+      (0, import_type_graphql.Authorized)()(GeneratedResolver, key);
+    }
+    (0, import_type_graphql.Root)()(GeneratedResolver.prototype, key, 0);
+    (0, import_type_graphql.FieldResolver)(() => def.output, def.outputOptions)(
+      GeneratedResolver.prototype,
+      key,
+      descriptor
+    );
+    (0, import_type_graphql.Ctx)()(GeneratedResolver.prototype, key, 1);
+    if (def.input) {
+      (0, import_type_graphql.Arg)("input", () => def.input || String, def.inputOptions)(
+        GeneratedResolver.prototype,
+        key,
+        2
+      );
+    }
+  }
+  return GeneratedResolver;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FieldLibrary,
+  QueryLibrary,
+  field,
+  query
+});

package/dist/graphql/utils.d.mts

@@ -0,0 +1,29 @@
+import { Context } from 'node:vm';
+import { ClassType, Query, Arg } from 'type-graphql';
+
+type ReturnOptions = Parameters<typeof Query>[1];
+type ArgsOptions = Parameters<typeof Arg>[2];
+interface BaseDefinition<X extends object, Y extends object> {
+    output: ClassType<Y> | [ClassType<Y>];
+    outputOptions?: ReturnOptions;
+    input?: ClassType<X>;
+    inputOptions?: ArgsOptions;
+    authorized?: boolean;
+}
+interface QueryDefinition<X extends object, Y extends object> extends BaseDefinition<X, Y> {
+    fn: (ctx: Context, data?: X) => Promise<Y> | Y;
+    mutation?: boolean;
+}
+interface FieldResolverDefinition<X extends object, Y extends object, Root> extends BaseDefinition<X, Y> {
+    fn: (root: Root, ctx: Context, data?: X) => Promise<Y> | Y;
+}
+declare function query<ReturnType extends object, ArgType extends object>(fn: QueryDefinition<ReturnType, ArgType>["fn"], options: Omit<QueryDefinition<ReturnType, ArgType>, "fn">): QueryDefinition<ReturnType, NonNullable<ArgType>>;
+declare function field<X extends object, Y extends object, Root>(fn: FieldResolverDefinition<X, Y, Root>["fn"], options: Omit<FieldResolverDefinition<X, Y, Root>, "fn">): FieldResolverDefinition<X, Y, Root>;
+declare function QueryLibrary<T extends Record<string, QueryDefinition<any, any>>>(queries: T): {
+    new (): {};
+};
+declare function FieldLibrary<X extends object, T extends Record<string, FieldResolverDefinition<any, any, X>> = Record<string, FieldResolverDefinition<any, any, X>>>(type: ClassType, queries: T): {
+    new (): {};
+};
+
+export { FieldLibrary, QueryLibrary, field, query };

package/dist/graphql/utils.d.ts

@@ -0,0 +1,29 @@
+import { Context } from 'node:vm';
+import { ClassType, Query, Arg } from 'type-graphql';
+
+type ReturnOptions = Parameters<typeof Query>[1];
+type ArgsOptions = Parameters<typeof Arg>[2];
+interface BaseDefinition<X extends object, Y extends object> {
+    output: ClassType<Y> | [ClassType<Y>];
+    outputOptions?: ReturnOptions;
+    input?: ClassType<X>;
+    inputOptions?: ArgsOptions;
+    authorized?: boolean;
+}
+interface QueryDefinition<X extends object, Y extends object> extends BaseDefinition<X, Y> {
+    fn: (ctx: Context, data?: X) => Promise<Y> | Y;
+    mutation?: boolean;
+}
+interface FieldResolverDefinition<X extends object, Y extends object, Root> extends BaseDefinition<X, Y> {
+    fn: (root: Root, ctx: Context, data?: X) => Promise<Y> | Y;
+}
+declare function query<ReturnType extends object, ArgType extends object>(fn: QueryDefinition<ReturnType, ArgType>["fn"], options: Omit<QueryDefinition<ReturnType, ArgType>, "fn">): QueryDefinition<ReturnType, NonNullable<ArgType>>;
+declare function field<X extends object, Y extends object, Root>(fn: FieldResolverDefinition<X, Y, Root>["fn"], options: Omit<FieldResolverDefinition<X, Y, Root>, "fn">): FieldResolverDefinition<X, Y, Root>;
+declare function QueryLibrary<T extends Record<string, QueryDefinition<any, any>>>(queries: T): {
+    new (): {};
+};
+declare function FieldLibrary<X extends object, T extends Record<string, FieldResolverDefinition<any, any, X>> = Record<string, FieldResolverDefinition<any, any, X>>>(type: ClassType, queries: T): {
+    new (): {};
+};
+
+export { FieldLibrary, QueryLibrary, field, query };

package/dist/graphql/utils.esm.js

@@ -0,0 +1,118 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+
+// src/graphql/utils.ts
+import {
+  Arg,
+  Authorized,
+  Ctx,
+  FieldResolver,
+  Mutation,
+  Query,
+  Resolver,
+  Root
+} from "type-graphql";
+function query(fn, options) {
+  return { ...options, fn };
+}
+function field(fn, options) {
+  return { ...options, fn };
+}
+function QueryLibrary(queries) {
+  let GeneratedResolver = class {
+  };
+  GeneratedResolver = __decorateClass([
+    Resolver()
+  ], GeneratedResolver);
+  for (const key in queries) {
+    const def = queries[key];
+    if (!def) continue;
+    Object.defineProperty(GeneratedResolver.prototype, key, {
+      // eslint-disable-next-line
+      value: async function(ctx, data) {
+        return def.fn(ctx, data);
+      },
+      writable: false
+    });
+    const descriptor = Object.getOwnPropertyDescriptor(
+      GeneratedResolver.prototype,
+      key
+    );
+    if (def.mutation) {
+      Mutation(() => def.output, def.outputOptions)(
+        GeneratedResolver.prototype,
+        key,
+        descriptor
+      );
+    } else {
+      Query(() => def.output, def.outputOptions)(
+        GeneratedResolver.prototype,
+        key,
+        descriptor
+      );
+    }
+    Ctx()(GeneratedResolver.prototype, key, 0);
+    if (def.input) {
+      Arg("input", () => def.input || String, def.inputOptions)(
+        GeneratedResolver.prototype,
+        key,
+        1
+      );
+    }
+  }
+  return GeneratedResolver;
+}
+function FieldLibrary(type, queries) {
+  let GeneratedResolver = class {
+  };
+  GeneratedResolver = __decorateClass([
+    Resolver(() => type)
+  ], GeneratedResolver);
+  for (const key in queries) {
+    const def = queries[key];
+    if (!def) continue;
+    Object.defineProperty(GeneratedResolver.prototype, key, {
+      // eslint-disable-next-line
+      value: async function(root, ctx, input) {
+        return def.fn(root, ctx, input);
+      },
+      writable: false
+    });
+    const descriptor = Object.getOwnPropertyDescriptor(
+      GeneratedResolver.prototype,
+      key
+    );
+    if (def.authorized) {
+      Authorized()(GeneratedResolver, key);
+    }
+    Root()(GeneratedResolver.prototype, key, 0);
+    FieldResolver(() => def.output, def.outputOptions)(
+      GeneratedResolver.prototype,
+      key,
+      descriptor
+    );
+    Ctx()(GeneratedResolver.prototype, key, 1);
+    if (def.input) {
+      Arg("input", () => def.input || String, def.inputOptions)(
+        GeneratedResolver.prototype,
+        key,
+        2
+      );
+    }
+  }
+  return GeneratedResolver;
+}
+export {
+  FieldLibrary,
+  QueryLibrary,
+  field,
+  query
+};