orchid-graphql 0.0.4 → 1.0.0

package/src/filters/filters.ts

@@ -1,93 +0,0 @@
-import { Query } from "pqb"
-
-import { is_plain_object } from "../utils/is-plain-object"
-import { Modifier } from "../utils/modifier"
-
-// TODO: per-field definitions
-export type FiltersDef = boolean
-
-export type FilterScalarValue = null | string | number | boolean
-export type FilterValue = FilterScalarValue | Exclude<FilterScalarValue, null>[]
-export type Filter = { [property: string]: FilterValue }
-
-function is_scalar(value: any) {
-	return (
-		value === null ||
-		typeof value === "string" ||
-		typeof value === "number" ||
-		typeof value === "boolean"
-	)
-}
-
-export function apply_filters({
-	query,
-	filters,
-	args,
-	modifiers,
-}: {
-	query: Query
-	filters: FiltersDef
-	args?: Record<string, any>
-	modifiers?: Record<string, Modifier>
-}) {
-	if (!filters) {
-		return query
-	}
-	const filter_obj = args?.filter
-	if (!filter_obj) {
-		return query
-	}
-	if (!is_plain_object(filter_obj)) {
-		throw new Error(`Invalid filter: ${filter_obj}, must be object.`)
-	}
-	for (const [field, value] of Object.entries(filter_obj)) {
-		if (value === undefined) {
-			// Support optional GraphQL arguments in filter
-			continue
-		}
-		if (modifiers?.[field]) {
-			query = modifiers[field](query, value)
-		} else {
-			// Normal filter
-			const [dbfield, op0] = field.split("__")
-			const op = op0?.toLowerCase() || "exact"
-			if (
-				// TODO: add the rest of orchid ops (or allow all of them?)
-				[
-					"exact",
-					"lt",
-					"lte",
-					"gt",
-					"gte",
-					"like",
-					"ilike",
-					"contains",
-				].includes(op)
-			) {
-				if (!is_scalar(value)) {
-					throw new Error(
-						`Unsupported filter value for ${query.table}.${field}: must be scalar.`
-					)
-				}
-				if (op === "exact") {
-					query = query.where({ [dbfield]: value })
-				} else {
-					const query_op = { like: "contains" }[op] || op
-					query = query.where({ [dbfield]: { [query_op]: value } })
-				}
-			} else if (op === "in") {
-				if (!(Array.isArray(value) && value.every(is_scalar))) {
-					throw new Error(
-						`Invalid filter value for ${query.table}.${field}: must be an array of scalars.`
-					)
-				}
-				query = query.whereIn(dbfield, value)
-			} else {
-				throw new Error(
-					`Invalid filter ${query.table}.${field}: unsupported operator ${op}.`
-				)
-			}
-		}
-	}
-	return query
-}

package/src/paginators/base.ts

@@ -1,40 +0,0 @@
-import { Query } from "pqb"
-
-export interface Paginator {
-	/** GraphQL path, for example: `["nodes"]` */
-	readonly path: string[]
-	paginate(query: Query, ...args: any[]): Query
-}
-
-type GetPageFn<P> = (nodes: any[]) => P
-
-const s = Symbol()
-
-// FIXME use proper orchid methods, set result type
-export function set_query_page_result<P>(query: Query, get_page: GetPageFn<P>) {
-	function _get_page(data: any) {
-		if (!Array.isArray(data)) {
-			throw new Error(`Paginator called for single result query.`)
-		}
-		return get_page(data)
-	}
-
-	// For root query
-	const _query = query.query
-	const { handleResult } = _query
-	_query.handleResult = (q, result, s) => {
-		const data = handleResult(q, result, s)
-		// Sometimes this is called for subqueries, sometimes not.
-		// TODO: investigate and use always.
-		return s ? data : _get_page(data)
-	}
-
-	// For subqueries
-	;(_query as any)[s] = _get_page
-
-	return query
-}
-
-export function get_query_pagination_handler(query: Query) {
-	return (query.query as any)[s]
-}

package/src/paginators/cursor.ts

@@ -1,113 +0,0 @@
-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
-
-		// 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

@@ -1,46 +0,0 @@
-import { Query } from "pqb"
-
-import { run_after_query } from "../utils/run-after"
-import { TableResolveContext } from "./table"
-
-export interface FieldResolveContext extends TableResolveContext {
-	/** GraphQL field */
-	field: string
-}
-
-/* A function that modifies the query to select a field. */
-export type FieldResolverFn = (
-	query: Query,
-	context: FieldResolveContext
-) => 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: FieldResolveContext): any
-}
-
-export function defineFieldResolver(
-	options: FieldResolverOptions = {}
-): FieldResolverFn {
-	const { tableField, modify, transform } = options
-
-	return function resolve(query, context) {
-		const { field } = context
-		if (modify) {
-			query = modify(query, context)
-		} else {
-			query = query.select({ [field]: tableField || field })
-		}
-		if (transform) {
-			query = run_after_query(query, async (instance) => {
-				instance[field] = await transform(instance[field], instance, context)
-				return instance
-			})
-		}
-		return query
-	}
-}

package/src/resolvers/page.ts

@@ -1,34 +0,0 @@
-import { overrideParserInQuery } from "orchid-core"
-
-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, modify } = options
-
-	return defineFieldResolver({
-		modify(query, context) {
-			const { field, graph } = context
-			// FIXME: refactor, add types
-			let get_page: any
-			query = query.select({
-				[field]: (q) => {
-					q = graph._resolve_page(
-						(q as any)[tableField || field],
-						paginator,
-						context
-					)
-					// Calling addParserToQuery here doesn't work, save the paginator for later.
-					get_page = get_query_pagination_handler(q)
-					return modify ? modify(q, context) : q
-				},
-			})
-			overrideParserInQuery(query.query, field, get_page)
-			return query
-		},
-	})
-}

package/src/resolvers/relation.ts

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

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

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

package/src/utils/modifier.ts

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

package/src/utils/run-after.ts

@@ -1,19 +0,0 @@
-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
-		}
-	})
-}