graphql-gene/dist/resolvers.js

Generates automatically an executable schema out of your ORM models

import { defaultFieldResolver as S } from "graphql";
import { getGloballyExtendedTypes as L, getGeneConfigFromOptions as w, lookDeepInSchema as G, parseGetterConfig as v, isArrayFieldConfig as b, getReturnTypeName as I, isUsingDefaultResolver as O, normalizeFieldConfig as j } from "./utils/index.js";
function U(e) {
  let i = e.schema;
  Object.entries(e.types).forEach(([, o]) => {
    const r = x({
      typeDefLines: e.typeDefLines,
      schema: i,
      types: e.types,
      plugins: e.plugins,
      model: o
    });
    r && (i = r);
  });
  const n = L(), s = p({
    typeDefLines: e.typeDefLines,
    schema: i,
    types: e.types,
    plugins: e.plugins,
    typeConfig: n.config,
    isAddingDirectives: !0
  });
  return s && (i = s), i;
}
function x(e) {
  const i = w(e), { types: n } = i || {};
  let s = p({ ...e, typeConfig: n });
  return Object.entries(i?.aliases || {}).forEach(([, o]) => {
    const { types: r } = o || {};
    s = p({ ...e, typeConfig: r });
  }), s;
}
function p(e) {
  const i = L().geneConfig, n = e.typeConfig || {};
  return G({
    schema: e.schema,
    each({ type: s, field: o, fieldDef: r, parentType: a }) {
      const l = i[s];
      if (!(e.isAddingDirectives && !!v(l?.directives)?.length) && !(a in n && n[a] && o in n[a])) return;
      let t;
      const y = n[a];
      if (y && !b(y)) {
        const c = y[o];
        t = c ? j(c) : void 0;
      }
      const g = I(
        t?.returnType || e.typeDefLines[a]?.lines[o]?.typeDef
      ), h = e.types[g];
      if (s !== g) return;
      const D = h ? e.plugins.find((c) => c.isMatching(h)) : void 0;
      if (t?.resolver && (r.resolve = async (c, u, m, f) => {
        if (t.resolver && typeof t.resolver != "string")
          return t.resolver({ source: c, args: u, context: m, info: f });
        if (O(t) && D?.defaultResolver)
          return await D.defaultResolver({
            model: h,
            modelKey: g,
            config: t,
            args: u,
            info: f
          });
      }), !e.isAddingDirectives) return;
      const d = [];
      if (l?.directives && d.push(...v(l.directives)), l?.aliases && g in l.aliases) {
        const c = l.aliases[g];
        c?.directives && d.push(...v(c.directives));
      }
      t?.directives && d.push(...v(t.directives)), d.length && [...d].reverse().forEach((u) => {
        r.resolve = r.resolve || S;
        const m = r.resolve;
        r.resolve = async (f, R, F, T) => {
          let A = !1, C;
          const E = async () => (A = !0, C = await m(f, R, F, T), C);
          return await u.handler({
            source: f,
            args: R,
            context: F,
            info: T,
            field: o,
            filter: z({ source: f, field: o }),
            resolve: E
          }), A || await E(), C;
        };
      });
    }
  }), e.schema;
}
function z(e) {
  const { field: i } = e;
  return (n) => {
    const s = e.source;
    Array.isArray(s[i]) ? s[i] = s[i].filter(n) : s[i] && !n(s[i]) && (s[i] = null);
  };
}
export {
  U as addResolversToSchema
};
//# sourceMappingURL=resolvers.js.map