naystack/dist/graphql/index.esm.js

A stack built with tight Next + Drizzle + GraphQL

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/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";
async function initGraphQLServer({
  authChecker,
  resolvers,
  plugins,
  context
}) {
  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
  });
  return {
    GET: (request) => handler(request),
    POST: (request) => handler(request),
    context
  };
}

// 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, {
      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, {
      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,
  initGraphQLServer,
  query
};