orchid-graphql 1.4.4 → 1.5.0

package/dist/index.d.cts

@@ -0,0 +1,179 @@
+import { GraphQLResolveInfo } from 'graphql';
+import { DbTable } from 'orchid-orm';
+import { Query } from 'pqb';
+
+interface FieldResolverOptions<Orm extends OrmAdapter, Context> {
+    /** Table field (if different from GraphQL field) */
+    tableField?: string;
+    /** Legacy alias for `tableField`. */
+    modelField?: string;
+    /** Custom query modifier (if different than simply selecting a field). */
+    modify?: FieldResolveModifier<Orm, Context>;
+    /** Post-process selected value. Return a new value or a promise. */
+    transform?(value: any, instance: any, context: FieldResolveContext<Orm, Context>): any;
+}
+type FieldResolveModifier<Orm extends OrmAdapter, Context> = (query: Orm["Query"], context: FieldResolveContext<Orm, Context>) => Orm["Query"];
+interface FieldResolveContext<Orm extends OrmAdapter, Context> extends TableResolveContext<Orm, Context> {
+    /** GraphQL field */
+    field: string;
+}
+type FieldResolver<Orm extends OrmAdapter, Context> = FieldResolveModifier<Orm, Context>;
+declare function defineFieldResolver<Orm extends OrmAdapter, Context>(options?: FieldResolverOptions<Orm, Context>): FieldResolver<Orm, Context>;
+
+interface TableResolverOptions<Orm extends OrmAdapter, Context> {
+    /** allow to resolve all table fields without explicitly listing them */
+    allowAllFields?: boolean;
+    /** allow to filter all table fields without explicitly listing them */
+    allowAllFilters?: boolean;
+    fields?: Record<string, SimpleFieldResolver<Orm, Context>>;
+    modifiers?: Record<string, ApplyFiltersModifier<Orm, Context>>;
+    modify?: TableResolveModifier<Orm, Context>;
+    transform?(instance: any, context: any): void | PromiseLike<void>;
+}
+type SimpleFieldResolver<Orm extends OrmAdapter, Context> = true | string | FieldResolver<Orm, Context>;
+type TableResolveModifier<Orm extends OrmAdapter, Context> = (query: Orm["Query"], context: TableResolveContext<Orm, Context>) => Orm["Query"];
+interface TableResolveContext<Orm extends OrmAdapter, Context> extends GraphResolveContext<Context> {
+    graph: GraphResolver<Orm, Context>;
+    /** GraphQL type */
+    type: string;
+}
+declare class TableResolver<Orm extends OrmAdapter, Context> {
+    readonly orm: Orm;
+    readonly table: Orm["Table"];
+    readonly options: TableResolverOptions<Orm, Context>;
+    readonly relations: Set<string>;
+    readonly virtual_fields: Set<string>;
+    readonly modifiers?: Record<string, ApplyFiltersModifier<Orm, Context>>;
+    readonly table_field_resolvers?: Record<string, FieldResolver<Orm, Context>>;
+    constructor(orm: Orm, table: Orm["Table"], options?: TableResolverOptions<Orm, Context>);
+    /** Modify query to select fields/relations and filter the result set. */
+    resolve(query: Orm["Query"], context: TableResolveContext<Orm, Context>): Orm["Query"];
+    /**
+     * Create field resolver which will modify query to resolve GraphQL field.
+     */
+    _get_default_field_resolver(field: string, tableField?: string): FieldResolver<Orm, Context>;
+}
+
+type FiltersDef = boolean;
+type ApplyFiltersModifier<Orm extends OrmAdapter, Context> = (query: Orm["Query"], value: any, context: TableResolveContext<Orm, Context>) => Orm["Query"];
+
+interface FieldsByTypeName {
+    [str: string]: {
+        [str: string]: ResolveTree;
+    };
+}
+interface ResolveTree {
+    name: string;
+    alias: string;
+    args: {
+        [str: string]: unknown;
+    };
+    fieldsByTypeName: FieldsByTypeName;
+}
+
+type GraphResolverOptions<Orm extends OrmAdapter, Context> = Pick<TableResolverOptions<Orm, Context>, "allowAllFields" | "allowAllFilters">;
+interface GraphResolveOptions<Context> {
+    info: GraphQLResolveInfo;
+    context: Context;
+    filters?: FiltersDef;
+    /** Subfield path if not resolving root query, e.g.: ['user'] */
+    path?: string[];
+}
+type GraphResolveContext<Context> = Omit<GraphResolveOptions<Context>, "info"> & {
+    tree: ResolveTree;
+};
+declare class GraphResolver<Orm extends OrmAdapter, Context> {
+    readonly orm: Orm;
+    readonly type_resolvers: Record<string, TableResolver<Orm, Context>>;
+    readonly options: GraphResolverOptions<Orm, Context>;
+    constructor(orm: Orm, type_resolvers: Record<string, TableResolver<Orm, Context>>, options?: GraphResolverOptions<Orm, Context>);
+    resolve(query: Orm["Query"], { info, ...context }: GraphResolveOptions<Context>): Orm["Query"] | undefined;
+    resolvePage(query: Orm["Query"], paginator: Paginator<Orm, Context>, { info, ...context }: GraphResolveOptions<Context>): Orm["QueryTransform"];
+    _get_resolve_tree(info: GraphQLResolveInfo): ResolveTree;
+    _resolve_type(query: Orm["Query"], context: GraphResolveContext<Context>): Orm["Query"] | undefined;
+    _resolve_page(query: Orm["Query"], paginator: Paginator<Orm, Context>, context: GraphResolveContext<Context>): Orm["QueryTransform"];
+}
+
+interface Paginator<Orm extends OrmAdapter, Context> {
+    /** GraphQL path, for example: `["nodes"]` */
+    readonly path: string[];
+    paginate(query: Orm["Query"], context: PaginateContext<Orm, Context>): Orm["QueryTransform"];
+}
+interface PaginateContext<Orm extends OrmAdapter, Context> extends GraphResolveContext<Context> {
+    graph: GraphResolver<Orm, Context>;
+}
+type GetPageFn = (nodes: any[]) => any;
+
+type OrmModifier<Orm extends OrmAdapter> = (query: Orm["Query"], ...args: any[]) => Orm["Query"];
+interface OrmAdapter<Table = any, Query = any, QueryTransform = any> {
+    Table: Table;
+    Query: Query;
+    QueryTransform: QueryTransform;
+    /** ORM table -> db table */
+    get_table_table(table: Table): string;
+    /** ORM table -> relation names */
+    get_table_relations(table: Table): string[];
+    /** ORM table -> virtual fields */
+    get_table_virtual_fields(table: Table): string[];
+    get_table_modifiers(table: Table): Record<string, OrmModifier<this>> | undefined;
+    /** ORM query -> db table */
+    get_query_table(query: Query): string;
+    select_field(query: Query, opts: {
+        field: string;
+        as: string;
+    }): Query;
+    select_relation(query: Query, opts: {
+        relation: string;
+        as: string;
+        modify: (subquery: Query) => Query;
+    }): Query;
+    where(query: Query, field: string, op: string | undefined, value: any): Query;
+    where_raw(query: Query, expression: string, bindings: Record<string, any>): Query;
+    reset_query_order(query: Query): Query;
+    add_query_order(query: Query, field: string, desc: boolean): Query;
+    set_query_limit(query: Query, limit: number): Query;
+    set_query_page_result(query: Query, get_page: GetPageFn): QueryTransform;
+    modify_subquery_pagination(subquery: Query, context: Record<string, any>): Query;
+    finish_query_pagination(query: Query, field: string, context: Record<string, any>): Query;
+    /** Set ORM query to run callback afterwards */
+    run_after_query(query: Query, fn: (result: any) => any): Query;
+    /** Prevent `SELECT *` by explicitly selecting ID */
+    prevent_select_all(query: Query): Query;
+}
+
+declare function defineCursorPaginator(options?: Partial<CursorPaginatorOptions>): CursorPaginator<OrmAdapter<any, any, any>, unknown>;
+interface CursorPaginatorOptions {
+    fields: string[];
+    take: number;
+}
+declare class CursorPaginator<Orm extends OrmAdapter, Context> implements Paginator<Orm, Context> {
+    readonly path: string[];
+    readonly options: CursorPaginatorOptions;
+    readonly fields: Array<{
+        name: string;
+        desc: boolean;
+    }>;
+    constructor(options?: Partial<CursorPaginatorOptions>);
+    paginate(query: Orm["Query"], context: PaginateContext<Orm, Context>): any;
+    _create_cursor(instance: any): string;
+    _parse_cursor(cursor: string): {
+        expression: string;
+        bindings: Record<string, any>;
+    };
+}
+
+interface RelationResolverOptions<Orm extends OrmAdapter, Context> extends Omit<FieldResolverOptions<Orm, Context>, "modify"> {
+    filters?: FiltersDef;
+    modify?: TableResolveModifier<Orm, Context>;
+}
+declare function defineRelationResolver<Orm extends OrmAdapter, Context>(options?: RelationResolverOptions<Orm, Context>): FieldResolver<Orm, Context>;
+
+declare function definePageResolver<Orm extends OrmAdapter, Context>(paginator: Paginator<Orm, Context>, options?: RelationResolverOptions<Orm, Context>): FieldResolver<Orm, Context>;
+
+type OrchidOrm = OrmAdapter<DbTable<any>, Query, Pick<Promise<any>, "then" | "catch">>;
+
+declare function createGraphResolver<Context = unknown>(types: Record<string, TableResolver<OrchidOrm, Context>>, options?: GraphResolverOptions<OrchidOrm, Context>): GraphResolver<OrchidOrm, Context>;
+
+declare function defineTableResolver<Context = unknown>(table: DbTable<any>, options?: TableResolverOptions<OrchidOrm, Context>): TableResolver<OrchidOrm, Context>;
+
+export { createGraphResolver, defineCursorPaginator as cursor, defineCursorPaginator, defineFieldResolver, definePageResolver, defineRelationResolver, defineTableResolver, defineFieldResolver as field, createGraphResolver as graph, definePageResolver as page, defineRelationResolver as relation, defineTableResolver as table };

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 import { GraphQLResolveInfo } from 'graphql';
-import { ResolveTree } from 'graphql-parse-resolve-info';
 import { DbTable } from 'orchid-orm';
 import { Query } from 'pqb';
 
@@ -58,6 +57,20 @@ declare class TableResolver<Orm extends OrmAdapter, Context> {
 type FiltersDef = boolean;
 type ApplyFiltersModifier<Orm extends OrmAdapter, Context> = (query: Orm["Query"], value: any, context: TableResolveContext<Orm, Context>) => Orm["Query"];
 
+interface FieldsByTypeName {
+    [str: string]: {
+        [str: string]: ResolveTree;
+    };
+}
+interface ResolveTree {
+    name: string;
+    alias: string;
+    args: {
+        [str: string]: unknown;
+    };
+    fieldsByTypeName: FieldsByTypeName;
+}
+
 type GraphResolverOptions<Orm extends OrmAdapter, Context> = Pick<TableResolverOptions<Orm, Context>, "allowAllFields" | "allowAllFilters">;
 interface GraphResolveOptions<Context> {
     info: GraphQLResolveInfo;

package/dist/index.js

@@ -123,8 +123,289 @@ function defineFieldResolver(options = {}) {
   };
 }
 
+// ../graphql-orm/src/utils/graphql-parse-resolve-info.ts
+import assert from "node:assert";
+import {
+  getNamedType,
+  GraphQLObjectType,
+  GraphQLUnionType,
+  isCompositeType
+} from "graphql";
+import { getArgumentValues } from "graphql";
+
+// ../graphql-orm/src/utils/graphql-parse-resolve-info-debug.ts
+function debugFactory(name) {
+  function debug2() {
+  }
+  debug2.enabled = false;
+  return debug2;
+}
+
+// ../graphql-orm/src/utils/graphql-parse-resolve-info.ts
+var debug = debugFactory("graphql-parse-resolve-info");
+var DEBUG_ENABLED = debug.enabled;
+function getArgVal(resolveInfo, argument) {
+  if (argument.kind === "Variable") {
+    return resolveInfo.variableValues[argument.name.value];
+  } else if (argument.kind === "BooleanValue") {
+    return argument.value;
+  }
+}
+function argNameIsIf(arg) {
+  return arg && arg.name ? arg.name.value === "if" : false;
+}
+function skipField(resolveInfo, { directives = [] }) {
+  let skip = false;
+  directives.forEach((directive) => {
+    const directiveName = directive.name.value;
+    if (Array.isArray(directive.arguments)) {
+      const ifArgumentAst = directive.arguments.find(argNameIsIf);
+      if (ifArgumentAst) {
+        const argumentValueAst = ifArgumentAst.value;
+        if (directiveName === "skip") {
+          skip = skip || getArgVal(resolveInfo, argumentValueAst);
+        } else if (directiveName === "include") {
+          skip = skip || !getArgVal(resolveInfo, argumentValueAst);
+        }
+      }
+    }
+  });
+  return skip;
+}
+function parseResolveInfo(resolveInfo, inOptions = {}) {
+  const fieldNodes = (
+    // @ts-ignore Property 'fieldASTs' does not exist on type 'GraphQLResolveInfo'.
+    resolveInfo.fieldNodes || resolveInfo.fieldASTs
+  );
+  const options = inOptions === true ? {} : inOptions;
+  const forceParse = inOptions === true || inOptions.forceParse;
+  const { parentType } = resolveInfo;
+  if (!fieldNodes) {
+    throw new Error("No fieldNodes provided!");
+  }
+  if (options.keepRoot == null) {
+    options.keepRoot = false;
+  }
+  if (options.deep == null) {
+    options.deep = true;
+  }
+  const tree = fieldTreeFromAST(
+    fieldNodes,
+    resolveInfo,
+    void 0,
+    options,
+    parentType
+  );
+  if (!options.keepRoot) {
+    const typeKey = firstKey(tree);
+    if (!typeKey) {
+      if (forceParse) {
+        throw new Error(
+          `GraphQL schema issue: simplified parseResolveInfo failed (tree had no keys); perhaps you need to use the keepRoot option?`
+        );
+      }
+      return null;
+    }
+    const fields = tree[typeKey];
+    const fieldKey = firstKey(fields);
+    if (!fieldKey) {
+      if (forceParse) {
+        throw new Error(
+          `GraphQL schema issue: simplified parseResolveInfo failed (could not get key from fields); perhaps you need to use the keepRoot option?`
+        );
+      }
+      return null;
+    }
+    return fields[fieldKey];
+  }
+  return tree;
+}
+function getFieldFromAST(ast, parentType) {
+  if (ast.kind === "Field") {
+    const fieldNode = ast;
+    const fieldName = fieldNode.name.value;
+    if (!(parentType instanceof GraphQLUnionType)) {
+      const type = parentType;
+      return type.getFields()[fieldName];
+    } else {
+    }
+  }
+  return void 0;
+}
+var iNum = 1;
+function fieldTreeFromAST(inASTs, resolveInfo, initTree = {}, options = {}, parentType, depth = "") {
+  const instance = iNum++;
+  if (DEBUG_ENABLED)
+    debug(
+      "%s[%d] Entering fieldTreeFromAST with parent type '%s'",
+      depth,
+      instance,
+      parentType
+    );
+  const { variableValues } = resolveInfo;
+  const fragments = resolveInfo.fragments || {};
+  const asts = Array.isArray(inASTs) ? inASTs : [inASTs];
+  if (!initTree[parentType.name]) {
+    initTree[parentType.name] = {};
+  }
+  const outerDepth = depth;
+  return asts.reduce((tree, selectionVal, idx) => {
+    const depth2 = DEBUG_ENABLED ? `${outerDepth}  ` : null;
+    if (DEBUG_ENABLED)
+      debug(
+        "%s[%d] Processing AST %d of %d; kind = %s",
+        depth2,
+        instance,
+        idx + 1,
+        asts.length,
+        selectionVal.kind
+      );
+    if (skipField(resolveInfo, selectionVal)) {
+      if (DEBUG_ENABLED)
+        debug("%s[%d] IGNORING due to directive", depth2, instance);
+    } else if (selectionVal.kind === "Field") {
+      const val = selectionVal;
+      const name = val.name.value;
+      const isReserved = name[0] === "_" && name[1] === "_" && name !== "__id";
+      if (isReserved) {
+        if (DEBUG_ENABLED)
+          debug(
+            "%s[%d] IGNORING because field '%s' is reserved",
+            depth2,
+            instance,
+            name
+          );
+      } else {
+        const alias = val.alias && val.alias.value ? val.alias.value : name;
+        if (DEBUG_ENABLED)
+          debug(
+            "%s[%d] Field '%s' (alias = '%s')",
+            depth2,
+            instance,
+            name,
+            alias
+          );
+        const field = getFieldFromAST(val, parentType);
+        if (field == null) {
+          return tree;
+        }
+        const fieldGqlTypeOrUndefined = getNamedType(field.type);
+        if (!fieldGqlTypeOrUndefined) {
+          return tree;
+        }
+        const fieldGqlType = fieldGqlTypeOrUndefined;
+        const args = getArgumentValues(
+          field,
+          val,
+          variableValues
+        ) || {};
+        if (parentType.name && !tree[parentType.name][alias]) {
+          const newTreeRoot = {
+            name,
+            alias,
+            args,
+            fieldsByTypeName: isCompositeType(fieldGqlType) ? {
+              [fieldGqlType.name]: {}
+            } : {}
+          };
+          tree[parentType.name][alias] = newTreeRoot;
+        }
+        const selectionSet = val.selectionSet;
+        if (selectionSet != null && options.deep && isCompositeType(fieldGqlType)) {
+          const newParentType = fieldGqlType;
+          if (DEBUG_ENABLED)
+            debug("%s[%d] Recursing into subfields", depth2, instance);
+          fieldTreeFromAST(
+            selectionSet.selections,
+            resolveInfo,
+            tree[parentType.name][alias].fieldsByTypeName,
+            options,
+            newParentType,
+            `${depth2}  `
+          );
+        } else {
+          if (DEBUG_ENABLED)
+            debug("%s[%d] Exiting (no fields to add)", depth2, instance);
+        }
+      }
+    } else if (selectionVal.kind === "FragmentSpread" && options.deep) {
+      const val = selectionVal;
+      const name = val.name && val.name.value;
+      if (DEBUG_ENABLED)
+        debug("%s[%d] Fragment spread '%s'", depth2, instance, name);
+      const fragment = fragments[name];
+      assert(fragment, 'unknown fragment "' + name + '"');
+      let fragmentType = parentType;
+      if (fragment.typeCondition) {
+        fragmentType = getType(resolveInfo, fragment.typeCondition);
+      }
+      if (fragmentType && isCompositeType(fragmentType)) {
+        const newParentType = fragmentType;
+        fieldTreeFromAST(
+          fragment.selectionSet.selections,
+          resolveInfo,
+          tree,
+          options,
+          newParentType,
+          `${depth2}  `
+        );
+      }
+    } else if (selectionVal.kind === "InlineFragment" && options.deep) {
+      const val = selectionVal;
+      const fragment = val;
+      let fragmentType = parentType;
+      if (fragment.typeCondition) {
+        fragmentType = getType(resolveInfo, fragment.typeCondition);
+      }
+      if (DEBUG_ENABLED)
+        debug(
+          "%s[%d] Inline fragment (parent = '%s', type = '%s')",
+          depth2,
+          instance,
+          parentType,
+          fragmentType
+        );
+      if (fragmentType && isCompositeType(fragmentType)) {
+        const newParentType = fragmentType;
+        fieldTreeFromAST(
+          fragment.selectionSet.selections,
+          resolveInfo,
+          tree,
+          options,
+          newParentType,
+          `${depth2}  `
+        );
+      }
+    } else {
+      if (DEBUG_ENABLED)
+        debug(
+          "%s[%d] IGNORING because kind '%s' not understood",
+          depth2,
+          instance,
+          selectionVal.kind
+        );
+    }
+    return tree;
+  }, initTree);
+}
+var hasOwnProperty = Object.prototype.hasOwnProperty;
+function firstKey(obj) {
+  for (const key in obj) {
+    if (hasOwnProperty.call(obj, key)) {
+      return key;
+    }
+  }
+}
+function getType(resolveInfo, typeCondition) {
+  const { schema } = resolveInfo;
+  const { kind, name } = typeCondition;
+  if (kind === "NamedType") {
+    const typeName = name.value;
+    return schema.getType(typeName);
+  }
+}
+
 // ../graphql-orm/src/resolvers/graph.ts
-import { parseResolveInfo } from "graphql-parse-resolve-info";
 var GraphResolver = class {
   constructor(orm2, type_resolvers, options = {}) {
     this.orm = orm2;
@@ -341,6 +622,7 @@ var TableResolver = class {
 };
 
 // src/orm/orm.ts
+import { raw } from "orchid-orm";
 var orm = {
   Table: void 0,
   Query: void 0,
@@ -378,7 +660,7 @@ var orm = {
     return query.where({ [field]: op ? { [op]: value } : value });
   },
   where_raw(query, expression, bindings) {
-    return query.where(query.sql({ raw: expression }).values(bindings));
+    return query.where(raw({ raw: expression, values: bindings }));
   },
   // Order & Limit
   reset_query_order(query) {