graphql-gene/dist/resolvers.js

Generates automatically an executable schema out of your ORM models

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