orchid-graphql 0.0.1

package/src/paginators/cursor.ts

@@ -0,0 +1,114 @@
+import { Query } from "pqb"
+
+import { Paginator, set_query_page_result } from "./base"
+
+export function defineCursorPaginator(
+	options: Partial<CursorPaginatorOptions> = {}
+) {
+	return new CursorPaginator(options)
+}
+
+export interface CursorPaginatorOptions {
+	fields: string[]
+	take: number
+}
+
+export interface CursorPaginatorArgs {
+	cursor?: string
+	take?: number
+}
+
+export interface CursorPaginatorPage<M> {
+	nodes: M[]
+	cursor?: string
+}
+
+class CursorPaginator implements Paginator {
+	readonly path = ["nodes"]
+	readonly options: CursorPaginatorOptions
+
+	readonly fields: Array<{
+		name: string
+		desc: boolean
+	}>
+
+	constructor(options: Partial<CursorPaginatorOptions> = {}) {
+		this.options = {
+			fields: ["id"],
+			take: 10,
+			...options,
+		}
+		this.fields = this.options.fields.map((field) => {
+			if (field.startsWith("-")) {
+				return { name: field.slice(1), desc: true }
+			} else {
+				return { name: field, desc: false }
+			}
+		})
+	}
+
+	paginate(query: Query, args: CursorPaginatorArgs = {}) {
+		const take = args.take ?? this.options.take
+		const { cursor } = args
+		console.log("paginating query", query)
+
+		// Set query order
+		query = query.clear("order")
+		for (const field of this.fields) {
+			// TODO: prevent potential name clash with aliases like .as(`_${table_ref}_order_key_0`)
+			query = query
+				.select(field.name)
+				.order({ [field.name]: field.desc ? "DESC" : "ASC" })
+		}
+
+		if (cursor) {
+			query = this._set_query_cursor(query, cursor)
+		}
+		query = query.limit(take + 1)
+
+		query = set_query_page_result(query, (nodes) => {
+			let cursor: string | undefined
+			if (nodes.length > take) {
+				cursor = this._create_cursor(nodes[take - 1])
+				nodes = nodes.slice(0, take)
+			}
+			return { nodes, cursor }
+		})
+
+		return query
+	}
+
+	_create_cursor(instance: any) {
+		return JSON.stringify(
+			this.fields.map((field) => {
+				const value = instance[field.name]
+				if (value === undefined) {
+					throw new Error(
+						`Unable to create cursor: undefined field ${field.name}`
+					)
+				}
+				return String(value)
+			})
+		)
+	}
+
+	_set_query_cursor(query: Query, cursor: string) {
+		const values = JSON.parse(cursor)
+		const left: string[] = []
+		const right: string[] = []
+		const expr_values: Record<string, any> = {}
+		// TODO: refactor
+		for (let i = 0; i < this.fields.length; ++i) {
+			const field = this.fields[i]
+			const expressions = field.desc ? right : left
+			const placeholders = field.desc ? left : right
+			expressions.push(`"${field.name}"`)
+			const placeholder = `value${i}`
+			placeholders.push("$" + placeholder)
+			expr_values[placeholder] = values[i]
+		}
+		return query.where(
+			query.raw(`(${left.join(",")}) > (${right.join(",")})`, expr_values)
+		)
+	}
+}

package/src/resolvers/field.ts

@@ -0,0 +1,51 @@
+import { ResolveTree } from "graphql-parse-resolve-info"
+import { Query } from "pqb"
+
+import { get_query_context } from "../utils/query-context"
+import { run_after_query } from "../utils/run-after"
+import type { GraphResolver } from "./graph"
+
+/* A function that modifies the query to select a field. */
+export type FieldResolverFn = (
+	query: Query,
+	options: {
+		/** GraphQL field */
+		field: string
+		/** GraphQL resolve tree */
+		tree: ResolveTree
+		/** Current graph resolver */
+		graph: GraphResolver
+	}
+) => Query
+
+export interface FieldResolverOptions {
+	/** Table field (if different from GraphQL field) */
+	tableField?: string
+	/** Custom query modifier (if different than simply selecting a field). */
+	modify?: FieldResolverFn
+	/** Post-process selected value. Return a new value or a promise. */
+	transform?(value: any, instance: any, context: any): any
+}
+
+export function defineFieldResolver(
+	options: FieldResolverOptions = {}
+): FieldResolverFn {
+	const { tableField, modify, transform } = options
+
+	return function resolve(query, options) {
+		const { field } = options
+		if (modify) {
+			return modify(query, options)
+		} else {
+			query = query.select({ [field]: tableField || field })
+		}
+		if (transform) {
+			const context = get_query_context(query)
+			query = run_after_query(query, async (instance) => {
+				instance[field] = await transform(instance[field], instance, context)
+				return instance
+			})
+		}
+		return query
+	}
+}

package/src/resolvers/graph.ts

@@ -0,0 +1,92 @@
+import { GraphQLResolveInfo } from "graphql"
+import { parseResolveInfo, ResolveTree } from "graphql-parse-resolve-info"
+import { Query } from "pqb"
+
+import { FiltersDef } from "../filters/filters"
+import { Paginator } from "../paginators/base"
+import { set_query_context } from "../utils/query-context"
+import type { TableResolverFn, TableResolverOptions } from "./table"
+
+export type GraphResolverOptions = Pick<
+	TableResolverOptions,
+	"allowAllFields" | "allowAllFilters"
+>
+
+export function createGraphResolver(
+	types: Record<string, TableResolverFn>,
+	options?: GraphResolverOptions
+) {
+	return new GraphResolver(types, options)
+}
+
+export interface GraphResolveOptions {
+	info: GraphQLResolveInfo
+	context: any
+	filters?: FiltersDef
+}
+
+export class GraphResolver {
+	constructor(
+		public readonly tables: Record<string, TableResolverFn>,
+		public readonly options: GraphResolverOptions = {}
+	) {}
+
+	resolve(query: Query, { info, context, filters }: GraphResolveOptions) {
+		set_query_context(query, context)
+		const tree = this._get_resolve_tree(info)
+		return this._resolve_type({ query, tree, filters })
+	}
+
+	resolvePage(
+		query: Query,
+		paginator: Paginator,
+		{ info, context, filters }: GraphResolveOptions
+	) {
+		set_query_context(query, context)
+		const tree = this._get_resolve_tree(info)
+		return this._resolve_page({ query, tree, paginator, filters })
+	}
+
+	_get_resolve_tree(info: GraphQLResolveInfo) {
+		return parseResolveInfo(info) as ResolveTree
+	}
+
+	_resolve_type({
+		tree,
+		query,
+		filters,
+	}: {
+		query: Query
+		tree: ResolveTree
+		filters?: FiltersDef
+	}) {
+		const type = Object.keys(tree.fieldsByTypeName)[0]
+		const table_resolver = this.tables[type]
+		if (!table_resolver) {
+			throw new Error(`Table resolver not found for type ${type}.`)
+		}
+		return table_resolver({ tree, type, query, filters, graph: this })
+	}
+
+	_resolve_page({
+		tree,
+		query,
+		paginator,
+		filters,
+	}: {
+		query: Query
+		tree: ResolveTree
+		paginator: Paginator
+		filters?: FiltersDef
+	}) {
+		const { args } = tree
+		// Skip page subtree(s)
+		for (const field of paginator.path) {
+			const type = Object.keys(tree.fieldsByTypeName)[0]
+			tree = tree.fieldsByTypeName[type][field]
+			// TODO: raise exception if not found
+		}
+		query = this._resolve_type({ query, tree, filters })
+		return paginator.paginate(query, args)
+	}
+}

package/src/resolvers/page.ts

@@ -0,0 +1,29 @@
+import { addParserToQuery } from "pqb"
+
+import { get_query_pagination_handler, Paginator } from "../paginators/base"
+import { defineFieldResolver } from "./field"
+import { RelationResolverOptions } from "./relation"
+
+export function definePageResolver(
+	paginator: Paginator,
+	options: RelationResolverOptions = {}
+) {
+	const { tableField, filters, modify } = options
+
+	return defineFieldResolver({
+		modify: (query, { field, tree, graph }) =>
+			query.select({
+				[field]: (q) => {
+					const page_query = graph._resolve_page({
+						tree,
+						query: (q as any)[tableField || field],
+						paginator,
+						filters,
+					})
+					const get_page = get_query_pagination_handler(page_query)
+					addParserToQuery(page_query.query, field, get_page as any)
+					return modify ? modify(page_query, tree) : page_query
+				},
+			}),
+	})
+}

package/src/resolvers/relation.ts

@@ -0,0 +1,27 @@
+import { FiltersDef } from "../filters/filters"
+import { defineFieldResolver, FieldResolverOptions } from "./field"
+import { QueryTreeModifier } from "./table"
+
+export interface RelationResolverOptions
+	extends Omit<FieldResolverOptions, "modify"> {
+	filters?: FiltersDef
+	modify?: QueryTreeModifier
+}
+
+export function defineRelationResolver(options: RelationResolverOptions = {}) {
+	const { tableField, filters, modify } = options
+
+	return defineFieldResolver({
+		modify: (query, { field, tree, graph }) =>
+			query.select({
+				[field]: (q) => {
+					const relation_query = graph._resolve_type({
+						tree,
+						query: (q as any)[tableField || field],
+						filters,
+					})
+					return modify ? modify(relation_query, tree) : relation_query
+				},
+			}),
+	})
+}

package/src/resolvers/table.ts

@@ -0,0 +1,146 @@
+import { ResolveTree } from "graphql-parse-resolve-info"
+import { DbTable, TableClass } from "orchid-orm"
+import { Query } from "pqb"
+
+import { apply_filters, FiltersDef } from "../filters/filters"
+import { Modifier } from "../utils/modifier"
+import { get_query_context } from "../utils/query-context"
+import { run_after_query } from "../utils/run-after"
+import { defineFieldResolver, FieldResolverFn } from "./field"
+import type { GraphResolver } from "./graph"
+import { defineRelationResolver } from "./relation"
+
+/** A function that modifies the query to select fields/relations and filter the result set. */
+export type TableResolverFn = (args: {
+	tree: ResolveTree
+	/** GraphQL type */
+	type: string
+	query: Query
+	filters?: FiltersDef
+	graph: GraphResolver
+}) => Query
+
+export interface TableResolverOptions {
+	/** 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>
+	modifiers?: Record<string, Modifier>
+	modify?: QueryTreeModifier
+	transform?(instance: any, context: any): void | PromiseLike<void>
+}
+
+export type SimpleFieldResolver = true | string | FieldResolverFn
+
+export type QueryTreeModifier = (query: Query, tree: ResolveTree) => Query
+
+export function defineTableResolver<T extends TableClass>(
+	table: DbTable<T>,
+	options: TableResolverOptions = {}
+): TableResolverFn {
+	/**
+	 * Create a field resolver which will modify the query to resolve a GraphQL field.
+	 */
+	const get_default_field_resolver = (
+		field: string,
+		tableField?: string
+	): FieldResolverFn | undefined => {
+		const table_field_lookup = tableField || field
+		if (options.modifiers?.[table_field_lookup]) {
+			// Keep query as is.
+			return (query) => query
+		} else if ((table.relations as any)?.[table_field_lookup]) {
+			return defineRelationResolver({ tableField })
+		} else {
+			return defineFieldResolver({ tableField })
+		}
+	}
+
+	// Pre-create field resolvers
+	const { fields } = options
+	const table_field_resolvers = fields
+		? Object.keys(fields).reduce<Record<string, FieldResolverFn>>(
+				(resolvers, field) => {
+					const r0 = fields[field]
+					const r: FieldResolverFn | undefined =
+						typeof r0 === "function"
+							? r0
+							: r0 === true
+							? get_default_field_resolver(field)
+							: typeof r0 === "string"
+							? get_default_field_resolver(field, r0)
+							: undefined
+					if (r === undefined) {
+						throw new Error(
+							`Field resolver must be a function, string, or true; found ${r0}`
+						)
+					}
+					resolvers[field] = r
+					return resolvers
+				},
+				{}
+		  )
+		: undefined
+
+	const { modify, transform } = options
+
+	return function resolve({ tree, type, query, filters, graph }) {
+		if (query.table !== table.table) {
+			throw new Error(
+				`Mismatching query type (expected ${table.table}, found ${query.table}).`
+			)
+		}
+
+		const allow_all_fields =
+			options.allowAllFields ??
+			graph.options.allowAllFields ??
+			table_field_resolvers === undefined
+
+		if (!allow_all_fields && !table_field_resolvers) {
+			throw new Error(
+				`Table resolver for ${type} must either allow all fields or specify options.fields`
+			)
+		}
+
+		if (modify) {
+			query = modify(query, tree)
+		}
+
+		for (const subtree of Object.values(tree.fieldsByTypeName[type])) {
+			const field = subtree.name
+			const r =
+				table_field_resolvers?.[field] ||
+				(allow_all_fields ? get_default_field_resolver(field) : undefined)
+			if (!r) {
+				throw new Error(`No field resolver defined for field ${type}.${field}`)
+			}
+			if (r) {
+				query = r(query, { field, tree: subtree, graph })
+			}
+		}
+
+		const allow_all_filters =
+			options.allowAllFilters ?? graph.options.allowAllFilters
+
+		const effective_filters = allow_all_filters ? true : filters
+
+		if (effective_filters) {
+			query = apply_filters({
+				query,
+				filters: effective_filters,
+				args: tree.args,
+				modifiers: options.modifiers,
+			})
+		}
+
+		if (transform) {
+			const context = get_query_context(query)
+			query = run_after_query(query, (instance) => {
+				return transform(instance, context)
+			})
+		}
+
+		return query
+	}
+}

package/src/utils/is-plain-object.ts

@@ -0,0 +1,3 @@
+export function is_plain_object(obj: any): obj is Record<string, any> {
+	return typeof obj === "object" && !Array.isArray(obj)
+}

package/src/utils/modifier.ts

@@ -0,0 +1,3 @@
+import { Query } from "pqb"
+
+export type Modifier = (query: Query, param?: any) => Query

package/src/utils/query-context.ts

@@ -0,0 +1,11 @@
+import { Query } from "pqb"
+
+const graphql = Symbol("graphql")
+
+export function set_query_context(query: Query, context: any) {
+	;(query.query as any)[graphql] = context
+}
+
+export function get_query_context(query: Query) {
+	return (query.query as any)[graphql]
+}

package/src/utils/run-after.ts

@@ -0,0 +1,19 @@
+import { Query } from "pqb"
+
+export function run_after_query(
+	query: Query,
+	transform: (instance: any) => any
+) {
+	return query.afterQuery(async (_, result) => {
+		// FIXME: returning is ignored in orchid (unlike objection). Add some hacks instead.
+		if (Array.isArray(result)) {
+			const result1 = await Promise.all(result.map(transform))
+			return result1.filter(Boolean) // Skip empty objects
+		} else if (result) {
+			return transform(result)
+		} else {
+			// Supposedly, single query builder returning NULL
+			return result
+		}
+	})
+}