@gqloom/core 0.8.4 → 0.9.1

package/README.md

@@ -18,14 +18,14 @@ import * as v from "valibot"
 
 const helloResolver = resolver({
   hello: query(v.string())
-  .input({ name: v.nullish(v.string(), "World") })
-  .resolve(({ name }) => `Hello, ${name}!`),
+    .input({ name: v.nullish(v.string(), "World") })
+    .resolve(({ name }) => `Hello, ${name}!`),
 })
 
 export const schema = ValibotWeaver.weave(helloResolver)
 ```
 
-## Highlights you should not miss
+## Highlights
 
 - 🧑‍💻 **Development Experience**: Fewer boilerplate codes, semantic API design, and extensive ecosystem integration make development enjoyable.
 - 🔒 **Type Safety**: Automatically infer types from the Schema, enjoy intelligent code completion during development, and detect potential problems during compilation.
@@ -34,6 +34,19 @@ export const schema = ValibotWeaver.weave(helloResolver)
 - 🔮 **No Magic**: Without decorators, metadata, reflection, or code generation, it can run anywhere with just JavaScript/TypeScript.
 - 🧩 **Rich Integration**: Use your most familiar validation libraries and ORMs to build your next GraphQL application.
 
+## Installation
+
+```bash
+# use npm
+npm install graphql @gqloom/core
+
+# use pnpm
+pnpm add graphql @gqloom/core
+
+# use yarn
+yarn add graphql @gqloom/core
+```
+
 ## Getting Started
 
 See [Getting Started](https://gqloom.dev/docs/getting-started) to learn how to use GQLoom.

package/dist/chunk-BQAPYNA7.js

@@ -0,0 +1,220 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/parse-resolving-fields.ts
+import {
+  Kind,
+  isObjectType
+} from "graphql";
+
+// src/utils/constants.ts
+var DERIVED_DEPENDENCIES = "loom.derived-from-dependencies";
+
+// src/utils/type.ts
+import { isListType } from "graphql";
+import { isNonNullType } from "graphql";
+function unwrapType(gqlType) {
+  if (isNonNullType(gqlType)) {
+    return unwrapType(gqlType.ofType);
+  }
+  if (isListType(gqlType)) {
+    return unwrapType(gqlType.ofType);
+  }
+  return gqlType;
+}
+
+// src/utils/parse-resolving-fields.ts
+function getResolvingFields(payload) {
+  const requestedFields = parseResolvingFields(payload.info);
+  const derivedFields = /* @__PURE__ */ new Set();
+  const derivedDependencies = /* @__PURE__ */ new Set();
+  const resolvingObject = unwrapType(payload.info.returnType);
+  if (isObjectType(resolvingObject)) {
+    const objectFields = resolvingObject.getFields();
+    for (const requestedFieldName of requestedFields) {
+      const field = objectFields[requestedFieldName];
+      if (field) {
+        const deps = field.extensions?.[DERIVED_DEPENDENCIES];
+        if (deps && Array.isArray(deps) && deps.length > 0) {
+          derivedFields.add(requestedFieldName);
+          for (const d of deps) derivedDependencies.add(d);
+        }
+      }
+    }
+  }
+  const selectedFields = new Set(requestedFields);
+  for (const f of derivedFields) selectedFields.delete(f);
+  for (const d of derivedDependencies) selectedFields.add(d);
+  return { requestedFields, derivedFields, derivedDependencies, selectedFields };
+}
+function parseResolvingFields(info, maxDepth = 1) {
+  return new ResolvingFieldsParser(info, maxDepth).parse();
+}
+var ResolvingFieldsParser = class {
+  /** Store unique field paths */
+  fields = /* @__PURE__ */ new Set();
+  /** Track visited fragments to prevent circular references */
+  visitedFragments = /* @__PURE__ */ new Set();
+  /** The GraphQL resolve info object */
+  info;
+  /** Maximum depth of nested fields to parse */
+  maxDepth;
+  constructor(info, maxDepth) {
+    this.info = info;
+    this.maxDepth = maxDepth;
+  }
+  /**
+   * Parses the GraphQL resolve info to extract all requested fields.
+   * @returns A Set of field paths
+   */
+  parse() {
+    for (const fieldNode of this.info.fieldNodes) {
+      this.collectFields(fieldNode.selectionSet);
+    }
+    return this.fields;
+  }
+  /**
+   * Recursively collects fields from a selection set.
+   * Handles fields, inline fragments, and fragment spreads.
+   *
+   * @param selectionSet - The selection set to process
+   * @param parentPath - The path of the parent field (for nested fields)
+   * @param currentDepth - Current depth of recursion
+   */
+  collectFields(selectionSet, parentPath = "", currentDepth = 0) {
+    if (!selectionSet?.selections.length || currentDepth >= this.maxDepth)
+      return;
+    for (const selection of selectionSet.selections) {
+      if (!this.shouldIncludeNode(selection)) continue;
+      switch (selection.kind) {
+        case Kind.FIELD: {
+          const fieldName = selection.name.value;
+          const fieldPath = parentPath ? `${parentPath}.${fieldName}` : fieldName;
+          this.fields.add(fieldPath);
+          const hasSelectionSet = selection.selectionSet != null;
+          if (hasSelectionSet) {
+            this.collectFields(
+              selection.selectionSet,
+              fieldPath,
+              currentDepth + 1
+            );
+          }
+          break;
+        }
+        case Kind.INLINE_FRAGMENT: {
+          if (selection.selectionSet) {
+            this.collectFields(selection.selectionSet, parentPath, currentDepth);
+          }
+          break;
+        }
+        case Kind.FRAGMENT_SPREAD: {
+          const fragmentName = selection.name.value;
+          if (this.visitedFragments.has(fragmentName)) continue;
+          this.visitedFragments.add(fragmentName);
+          const fragment = this.info.fragments[fragmentName];
+          if (fragment) {
+            this.collectFields(fragment.selectionSet, parentPath, currentDepth);
+          }
+          break;
+        }
+      }
+    }
+  }
+  /**
+   * Extracts the boolean value from a directive's 'if' argument.
+   * Handles both literal boolean values and variables.
+   *
+   * @param directive - The directive node to extract value from
+   * @returns The boolean value of the directive's condition
+   */
+  getDirectiveValue(directive) {
+    const ifArg = directive.arguments?.find(
+      (arg) => arg.name.value === "if"
+    );
+    if (!ifArg) return true;
+    const value = ifArg.value;
+    if (value.kind === Kind.BOOLEAN) {
+      return value.value;
+    }
+    if (value.kind === Kind.VARIABLE) {
+      const variableName = value.name.value;
+      const variableValue = this.info.variableValues?.[variableName];
+      return variableValue === true;
+    }
+    return true;
+  }
+  /**
+   * Determines if a selection node should be included based on its directives.
+   * Handles both @include and @skip directives.
+   *
+   * @param node - The selection node to check
+   * @returns Whether the node should be included
+   */
+  shouldIncludeNode(node) {
+    if (!node.directives?.length) return true;
+    return node.directives.every((directive) => {
+      const isIncludeDirective = directive.name.value === "include";
+      if (isIncludeDirective) {
+        return this.getDirectiveValue(directive);
+      }
+      if (directive.name.value === "skip") {
+        return !this.getDirectiveValue(directive);
+      }
+      return true;
+    });
+  }
+};
+
+// src/utils/symbols.ts
+var symbols_exports = {};
+__export(symbols_exports, {
+  CONTEXT_MAP_KEY: () => CONTEXT_MAP_KEY,
+  FIELD_HIDDEN: () => FIELD_HIDDEN,
+  GET_GRAPHQL_TYPE: () => GET_GRAPHQL_TYPE,
+  IS_RESOLVER: () => IS_RESOLVER,
+  RESOLVER_OPTIONS_KEY: () => RESOLVER_OPTIONS_KEY,
+  WEAVER_CONFIG: () => WEAVER_CONFIG
+});
+var GET_GRAPHQL_TYPE = Symbol.for("gqloom.get_graphql_type");
+var WEAVER_CONFIG = Symbol.for("gqloom.weaver_config");
+var RESOLVER_OPTIONS_KEY = Symbol.for("gqloom.resolver-options");
+var IS_RESOLVER = Symbol.for("gqloom.is-resolver");
+var CONTEXT_MAP_KEY = Symbol.for("gqloom.context-map");
+var FIELD_HIDDEN = Symbol.for("gqloom.field-hidden");
+
+// src/utils/context.ts
+function onlyMemoization() {
+  return { memoization: /* @__PURE__ */ new WeakMap(), isMemoization: true };
+}
+function isOnlyMemoryPayload(payload) {
+  return payload.isMemoization === true;
+}
+function getMemoizationMap(payload) {
+  if (isOnlyMemoryPayload(payload)) return payload.memoization;
+  if (typeof payload.context === "undefined") {
+    Object.defineProperty(payload, "context", { value: {} });
+  }
+  return assignContextMap(payload.context);
+}
+function assignContextMap(target) {
+  target[CONTEXT_MAP_KEY] ??= /* @__PURE__ */ new WeakMap();
+  return target[CONTEXT_MAP_KEY];
+}
+
+export {
+  DERIVED_DEPENDENCIES,
+  getResolvingFields,
+  parseResolvingFields,
+  GET_GRAPHQL_TYPE,
+  WEAVER_CONFIG,
+  IS_RESOLVER,
+  FIELD_HIDDEN,
+  symbols_exports,
+  onlyMemoization,
+  isOnlyMemoryPayload,
+  getMemoizationMap,
+  assignContextMap
+};