orchid-graphql 1.9.0 → 2.0.0

package/dist/index.cjs

@@ -1,520 +1,373 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  createGraphResolver: () => createGraphResolver,
-  cursor: () => defineCursorPaginator,
-  defineCursorPaginator: () => defineCursorPaginator,
-  defineFieldResolver: () => defineFieldResolver,
-  definePageResolver: () => definePageResolver,
-  defineRelationResolver: () => defineRelationResolver,
-  defineTableResolver: () => defineTableResolver,
-  field: () => defineFieldResolver,
-  filterQuery: () => filterQuery2,
-  graph: () => createGraphResolver,
-  page: () => definePageResolver,
-  relation: () => defineRelationResolver,
-  table: () => defineTableResolver
-});
-module.exports = __toCommonJS(index_exports);
-
-// ../base/src/utils/is-plain-object.ts
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let graphql_parse_resolve_info = require("graphql-parse-resolve-info");
+let orchid_pagination = require("orchid-pagination");
+//#region ../base/src/utils/is-plain-object.ts
 function isPlainObject(obj) {
-  return typeof obj === "object" && !Array.isArray(obj);
+	return typeof obj === "object" && !Array.isArray(obj);
 }
-
-// ../base/src/filter/filter.ts
-function filterQuery(orm2, query, filter, options) {
-  const { context, modifiers } = options ?? {};
-  if (!filter) {
-    return query;
-  }
-  if (!isPlainObject(filter)) {
-    throw new Error(`Invalid filter: ${filter}, must be plain object.`);
-  }
-  for (const [field, value] of Object.entries(filter)) {
-    if (value === void 0) {
-      continue;
-    }
-    if (modifiers?.[field]) {
-      query = modifiers[field](query, value, context);
-    } else {
-      const [table_field, op0] = field.split("__");
-      const op = op0?.toLowerCase();
-      query = orm2.where(query, table_field, op, value);
-    }
-  }
-  return query;
+//#endregion
+//#region ../base/src/filter/filter.ts
+function filterQuery$1(orm, query, filter, options) {
+	const { context, modifiers } = options ?? {};
+	if (!filter) return query;
+	if (!isPlainObject(filter)) throw new Error(`Invalid filter: ${filter}, must be plain object.`);
+	for (const [field, value] of Object.entries(filter)) {
+		if (value === void 0) continue;
+		if (modifiers === null || modifiers === void 0 ? void 0 : modifiers[field]) query = modifiers[field](query, value, context);
+		else {
+			const [tableField, op0] = field.split("__");
+			const op = op0 === null || op0 === void 0 ? void 0 : op0.toLowerCase();
+			query = orm.where(query, tableField, op, value);
+		}
+	}
+	return query;
 }
-
-// ../base/src/paginators/cursor.ts
-var import_node_buffer = require("buffer");
+//#endregion
+//#region ../base/src/paginators/cursor.ts
 function defineCursorPaginator(options = {}) {
-  return new CursorPaginator(options);
+	return new CursorPaginator(options);
 }
 var CursorPaginator = class {
-  path = ["nodes"];
-  pageSize;
-  fields;
-  constructor(options = {}) {
-    this.pageSize = options.take ?? 10;
-    this.fields = options.fields?.map((field) => {
-      if (field.startsWith("-")) {
-        return { name: field.slice(1), desc: true };
-      } else {
-        return { name: field, desc: false };
-      }
-    });
-  }
-  paginate(query, context) {
-    const { orm: orm2 } = context.graph;
-    const { args } = context.tree;
-    const pageSize = args.take ?? this.pageSize;
-    const cursor = args.cursor;
-    const table = orm2.get_query_table(query);
-    const orderFields = (this.fields ? this.fields.map((f) => ({
-      field: f.name,
-      dir: f.desc ? "DESC" : "ASC"
-    })) : orm2.get_query_order(query)).map((o) => ({ ...o, alias: "_order_" + o.field }));
-    if (this.fields) {
-      query = orm2.reset_query_order(query);
-      for (const { alias, dir } of orderFields) {
-        query = orm2.add_query_order(query, { field: alias, dir });
-      }
-    }
-    if (!orderFields.length) {
-      throw new Error("Query must be ordered.");
-    }
-    for (const { field, alias } of orderFields) {
-      query = orm2.select_field(query, { field, as: alias });
-    }
-    if (cursor) {
-      const parsedCursor = parseCursor(cursor);
-      const left = [];
-      const right = [];
-      for (let i = 0; i < orderFields.length; ++i) {
-        const { field, alias, dir } = orderFields[i];
-        const [expressions, placeholders] = dir === "ASC" ? [left, right] : [right, left];
-        expressions.push(`"${table}"."${field}"`);
-        placeholders.push("$" + alias);
-      }
-      const sqlExpr = `(${left.join(",")}) > (${right.join(",")})`;
-      const bindings = Object.fromEntries(
-        orderFields.map(({ alias }, i) => [alias, parsedCursor[i]])
-      );
-      query = orm2.where_raw(query, sqlExpr, bindings);
-    }
-    query = orm2.set_query_limit(query, pageSize + 1);
-    function createNodeCursor(node) {
-      return createCursor(
-        orderFields.map(({ field, alias }) => {
-          const value = node[alias];
-          if (value === void 0) {
-            throw new Error(
-              `Unable to create cursor: undefined field ${field} (${alias})`
-            );
-          }
-          return String(value);
-        })
-      );
-    }
-    return orm2.set_query_page_result(query, (nodes) => {
-      let cursor2;
-      if (nodes.length > pageSize) {
-        cursor2 = createNodeCursor(nodes[pageSize - 1]);
-        nodes = nodes.slice(0, pageSize);
-      }
-      return { nodes, cursor: cursor2 };
-    });
-  }
+	path = ["nodes"];
+	pageSize;
+	fields;
+	constructor(options = {}) {
+		var _options$fields;
+		this.pageSize = options.take ?? 10;
+		this.fields = (_options$fields = options.fields) === null || _options$fields === void 0 ? void 0 : _options$fields.map((field) => {
+			if (field.startsWith("-")) return {
+				field: field.slice(1),
+				dir: "DESC"
+			};
+			else return {
+				field,
+				dir: "ASC"
+			};
+		});
+	}
+	paginate(query, context) {
+		const { orm } = context.graph;
+		const { args } = context.tree;
+		const pageSize = args.take ?? this.pageSize;
+		const cursor = args.cursor;
+		const prepared = orm.prepareCursorPagination(query, {
+			cursor,
+			fields: this.fields,
+			limit: pageSize
+		});
+		return orm.setQueryPageResult(prepared.query, prepared.getPage);
+	}
 };
-function createCursor(parts) {
-  return import_node_buffer.Buffer.from(parts.map(String).join(String.fromCharCode(0))).toString(
-    "base64url"
-  );
-}
-function parseCursor(cursor) {
-  return import_node_buffer.Buffer.from(cursor, "base64url").toString().split(String.fromCharCode(0));
+//#endregion
+//#region ../base/src/utils/run-after.ts
+function runAfterQuery(orm, query, transform) {
+	return orm.runAfterQuery(query, async (result) => {
+		if (Array.isArray(result)) return (await Promise.all(result.map(transform))).filter(Boolean);
+		else if (result) return transform(result);
+		else return result;
+	});
 }
-
-// ../base/src/utils/run-after.ts
-function run_after_query(orm2, query, transform) {
-  return orm2.run_after_query(query, async (result) => {
-    if (Array.isArray(result)) {
-      const result1 = await Promise.all(result.map(transform));
-      return result1.filter(Boolean);
-    } else if (result) {
-      return transform(result);
-    } else {
-      return result;
-    }
-  });
-}
-
-// ../base/src/resolvers/field.ts
-function parse_field_options(options) {
-  const { tableField, modelField } = options;
-  if (tableField && modelField) {
-    throw new Error(
-      `Both tableField and modelField are defined. Use only one of them.`
-    );
-  }
-  return { ...options, tableField: tableField || modelField };
+//#endregion
+//#region ../base/src/resolvers/field.ts
+function parseFieldOptions(options) {
+	const { tableField, modelField } = options;
+	if (tableField && modelField) throw new Error(`Both tableField and modelField are defined. Use only one of them.`);
+	return {
+		...options,
+		tableField: tableField || modelField
+	};
 }
 function defineFieldResolver(options = {}) {
-  const { tableField, modify, transform } = parse_field_options(options);
-  return function resolve(query, context) {
-    const { field } = context;
-    if (modify) {
-      query = modify(query, context);
-    } else {
-      query = context.graph.orm.select_field(query, {
-        field: tableField || field,
-        as: field
-      });
-    }
-    if (transform) {
-      query = run_after_query(context.graph.orm, query, async (instance) => {
-        instance[field] = await transform(instance[field], instance, context);
-        return instance;
-      });
-    }
-    return query;
-  };
+	const { tableField, modify, transform } = parseFieldOptions(options);
+	return function resolve(query, context) {
+		const { field } = context;
+		if (modify) query = modify(query, context);
+		else query = context.graph.orm.selectField(query, {
+			field: tableField || field,
+			as: field
+		});
+		if (transform) query = runAfterQuery(context.graph.orm, query, async (instance) => {
+			instance[field] = await transform(instance[field], instance, context);
+			return instance;
+		});
+		return query;
+	};
 }
-
-// ../base/src/resolvers/graph.ts
-var import_graphql_parse_resolve_info = require("graphql-parse-resolve-info");
+//#endregion
+//#region ../base/src/resolvers/graph.ts
 var GraphResolver = class {
-  constructor(orm2, type_resolvers, options = {}) {
-    this.orm = orm2;
-    this.type_resolvers = type_resolvers;
-    this.options = options;
-  }
-  resolve(query, { info, ...context }) {
-    const tree = this._get_resolve_tree(info);
-    return this._resolve_type(query, { ...context, tree });
-  }
-  resolvePage(query, paginator, { info, ...context }) {
-    const tree = this._get_resolve_tree(info);
-    return this._resolve_page(query, paginator, { ...context, tree });
-  }
-  _get_resolve_tree(info) {
-    return (0, import_graphql_parse_resolve_info.parseResolveInfo)(info);
-  }
-  _resolve_type(query, context) {
-    let { tree } = context;
-    if (context.path) {
-      for (const field of context.path) {
-        const type2 = Object.keys(tree.fieldsByTypeName)[0];
-        tree = tree.fieldsByTypeName[type2][field];
-        if (!tree) {
-          return Promise.resolve();
-        }
-      }
-    }
-    const type = Object.keys(tree.fieldsByTypeName)[0];
-    const type_resolver = this.type_resolvers[type];
-    if (!type_resolver) {
-      throw new Error(`Resolver not found for type ${type}.`);
-    }
-    return type_resolver.resolve(query, {
-      ...context,
-      graph: this,
-      tree,
-      type,
-      path: void 0
-    });
-  }
-  _resolve_page(query, paginator, context) {
-    if (context.path) {
-      throw new Error("Paginating under non-root path not yet supported.");
-    }
-    query = this._resolve_type(query, { ...context, path: paginator.path });
-    return paginator.paginate(query, {
-      ...context,
-      graph: this
-    });
-  }
+	orm;
+	typeResolvers;
+	options;
+	constructor(orm, typeResolvers, options = {}) {
+		this.orm = orm;
+		this.typeResolvers = typeResolvers;
+		this.options = options;
+	}
+	resolve(query, { info, ...context }) {
+		const tree = this._getResolveTree(info);
+		return this._resolveType(query, {
+			...context,
+			tree
+		});
+	}
+	resolvePage(query, paginator, { info, ...context }) {
+		const tree = this._getResolveTree(info);
+		return this._resolvePage(query, paginator, {
+			...context,
+			tree
+		});
+	}
+	_getResolveTree(info) {
+		return (0, graphql_parse_resolve_info.parseResolveInfo)(info);
+	}
+	_resolveType(query, context) {
+		let { tree } = context;
+		if (context.path) for (const field of context.path) {
+			const type = Object.keys(tree.fieldsByTypeName)[0];
+			tree = tree.fieldsByTypeName[type][field];
+			if (!tree) return Promise.resolve();
+		}
+		const type = Object.keys(tree.fieldsByTypeName)[0];
+		const typeResolver = this.typeResolvers[type];
+		if (!typeResolver) throw new Error(`Resolver not found for type ${type}.`);
+		return typeResolver.resolve(query, {
+			...context,
+			graph: this,
+			tree,
+			type,
+			path: void 0
+		});
+	}
+	_resolvePage(query, paginator, context) {
+		if (context.path) throw new Error("Paginating under non-root path not yet supported.");
+		query = this._resolveType(query, {
+			...context,
+			path: paginator.path
+		});
+		return paginator.paginate(query, {
+			...context,
+			graph: this
+		});
+	}
 };
-
-// ../base/src/resolvers/page.ts
+//#endregion
+//#region ../base/src/resolvers/page.ts
 function definePageResolver(paginator, options = {}) {
-  const { tableField, modify } = parse_field_options(options);
-  return function resolve(query, context) {
-    const { graph, field } = context;
-    const pagination_context = {};
-    query = graph.orm.select_relation(query, {
-      relation: tableField || field,
-      as: field,
-      modify(subquery) {
-        subquery = modify ? modify(subquery, context) : subquery;
-        subquery = graph._resolve_page(subquery, paginator, context);
-        subquery = graph.orm.modify_subquery_pagination(
-          subquery,
-          pagination_context
-        );
-        return subquery;
-      }
-    });
-    query = graph.orm.finish_query_pagination(query, field, pagination_context);
-    return query;
-  };
+	const { tableField, modify } = parseFieldOptions(options);
+	return function resolve(query, context) {
+		const { graph, field } = context;
+		const paginationContext = {};
+		query = graph.orm.selectRelation(query, {
+			relation: tableField || field,
+			as: field,
+			modify(subquery) {
+				subquery = modify ? modify(subquery, context) : subquery;
+				subquery = graph._resolvePage(subquery, paginator, context);
+				subquery = graph.orm.modifySubqueryPagination(subquery, paginationContext);
+				return subquery;
+			}
+		});
+		query = graph.orm.finishQueryPagination(query, field, paginationContext);
+		return query;
+	};
 }
-
-// ../base/src/resolvers/relation.ts
+//#endregion
+//#region ../base/src/resolvers/relation.ts
 function defineRelationResolver(options = {}) {
-  const { tableField, filters, modify } = parse_field_options(options);
-  return function resolve(query, context) {
-    const { graph, field } = context;
-    return graph.orm.select_relation(query, {
-      relation: tableField || field,
-      as: field,
-      modify(subquery) {
-        subquery = graph._resolve_type(subquery, { ...context, filters });
-        return modify ? modify(subquery, context) : subquery;
-      }
-    });
-  };
+	const { tableField, filters, modify } = parseFieldOptions(options);
+	return function resolve(query, context) {
+		const { graph, field } = context;
+		return graph.orm.selectRelation(query, {
+			relation: tableField || field,
+			as: field,
+			modify(subquery) {
+				subquery = graph._resolveType(subquery, {
+					...context,
+					filters
+				});
+				return modify ? modify(subquery, context) : subquery;
+			}
+		});
+	};
 }
-
-// ../base/src/resolvers/table.ts
+//#endregion
+//#region ../base/src/resolvers/table.ts
 var TableResolver = class {
-  constructor(orm2, table, options = {}) {
-    this.orm = orm2;
-    this.table = table;
-    this.options = options;
-    this.relations = new Set(orm2.get_table_relations(table));
-    this.virtual_fields = new Set(orm2.get_table_virtual_fields(table));
-    this.modifiers = { ...orm2.get_table_modifiers(table), ...options.modifiers };
-    const { fields } = options;
-    if (fields) {
-      this.table_field_resolvers = Object.keys(fields).reduce((resolvers, field) => {
-        const r0 = fields[field];
-        const r = typeof r0 === "function" ? r0 : r0 === true ? this._get_default_field_resolver(field) : typeof r0 === "string" ? this._get_default_field_resolver(field, r0) : void 0;
-        if (r === void 0) {
-          throw new Error(
-            `Field resolver must be a function, string, or true; found ${typeof r0}.`
-          );
-        }
-        resolvers[field] = r;
-        return resolvers;
-      }, {});
-    }
-  }
-  // Introspection results
-  relations;
-  virtual_fields;
-  modifiers;
-  table_field_resolvers;
-  /** Modify query to select fields/relations and filter the result set. */
-  resolve(query, context) {
-    const { modify, transform } = this.options;
-    const { graph, tree, type, filters } = context;
-    const query_table = this.orm.get_query_table(query);
-    const table_table = this.orm.get_table_table(this.table);
-    if (query_table !== table_table) {
-      throw new Error(
-        `Mismatching query table for type ${type}: expected ${table_table}, received ${query_table}.`
-      );
-    }
-    const allow_all_fields = this.options.allowAllFields ?? graph.options.allowAllFields ?? !this.options.fields;
-    if (!allow_all_fields && !this.table_field_resolvers) {
-      throw new Error(
-        `Resolver for type ${type} must either allow all fields or specify options.fields.`
-      );
-    }
-    if (modify) {
-      query = modify(query, context);
-    }
-    for (const subtree of Object.values(tree.fieldsByTypeName[type])) {
-      const field = subtree.name;
-      const r = this.table_field_resolvers?.[field] || (allow_all_fields ? this._get_default_field_resolver(field) : void 0);
-      if (!r) {
-        throw new Error(`No field resolver defined for field ${type}.${field}.`);
-      }
-      if (r) {
-        query = r(query, { ...context, tree: subtree, field });
-      }
-    }
-    const filter = context.tree.args?.filter;
-    if (filter) {
-      const allowAllFilters = this.options.allowAllFilters ?? graph.options.allowAllFilters;
-      const filterConfig = allowAllFilters ? true : filters;
-      if (filterConfig) {
-        query = filterQuery(context.graph.orm, query, filter, {
-          modifiers: this.modifiers,
-          context
-        });
-      }
-    }
-    if (transform) {
-      query = run_after_query(this.orm, query, (instance) => {
-        return transform(instance, context);
-      });
-    }
-    query = this.orm.prevent_select_all(query);
-    return query;
-  }
-  /**
-   * Create field resolver which will modify query to resolve GraphQL field.
-   */
-  _get_default_field_resolver(field, tableField) {
-    const table_field_lookup = tableField || field;
-    if (this.options.modifiers?.[table_field_lookup] || this.virtual_fields.has(table_field_lookup)) {
-      return (query) => query;
-    } else if (this.relations.has(table_field_lookup)) {
-      return defineRelationResolver({ tableField });
-    } else {
-      return defineFieldResolver({ tableField });
-    }
-  }
+	orm;
+	table;
+	options;
+	relations;
+	virtualFields;
+	modifiers;
+	tableFieldResolvers;
+	constructor(orm, table, options = {}) {
+		this.orm = orm;
+		this.table = table;
+		this.options = options;
+		this.relations = new Set(orm.getTableRelations(table));
+		this.virtualFields = new Set(orm.getTableVirtualFields(table));
+		this.modifiers = {
+			...orm.getTableModifiers(table),
+			...options.modifiers
+		};
+		const { fields } = options;
+		if (fields) this.tableFieldResolvers = Object.keys(fields).reduce((resolvers, field) => {
+			const r0 = fields[field];
+			const r = typeof r0 === "function" ? r0 : r0 === true ? this._getDefaultFieldResolver(field) : typeof r0 === "string" ? this._getDefaultFieldResolver(field, r0) : void 0;
+			if (r === void 0) throw new Error(`Field resolver must be a function, string, or true; found ${typeof r0}.`);
+			resolvers[field] = r;
+			return resolvers;
+		}, {});
+	}
+	/** Modify query to select fields/relations and filter the result set. */
+	resolve(query, context) {
+		var _context$tree$args;
+		const { modify, transform } = this.options;
+		const { graph, tree, type, filters } = context;
+		const queryTable = this.orm.getQueryTable(query);
+		const tableName = this.orm.getTableName(this.table);
+		if (queryTable !== tableName) throw new Error(`Mismatching query table for type ${type}: expected ${tableName}, received ${queryTable}.`);
+		const allowAllFields = this.options.allowAllFields ?? graph.options.allowAllFields ?? !this.options.fields;
+		if (!allowAllFields && !this.tableFieldResolvers) throw new Error(`Resolver for type ${type} must either allow all fields or specify options.fields.`);
+		if (modify) query = modify(query, context);
+		for (const subtree of Object.values(tree.fieldsByTypeName[type])) {
+			var _this$tableFieldResol;
+			const field = subtree.name;
+			const r = ((_this$tableFieldResol = this.tableFieldResolvers) === null || _this$tableFieldResol === void 0 ? void 0 : _this$tableFieldResol[field]) || (allowAllFields ? this._getDefaultFieldResolver(field) : void 0);
+			if (!r) throw new Error(`No field resolver defined for field ${type}.${field}.`);
+			if (r) query = r(query, {
+				...context,
+				tree: subtree,
+				field
+			});
+		}
+		const filter = (_context$tree$args = context.tree.args) === null || _context$tree$args === void 0 ? void 0 : _context$tree$args.filter;
+		if (filter) {
+			if (this.options.allowAllFilters ?? graph.options.allowAllFilters ? true : filters) query = filterQuery$1(context.graph.orm, query, filter, {
+				modifiers: this.modifiers,
+				context
+			});
+		}
+		if (transform) query = runAfterQuery(this.orm, query, (instance) => {
+			return transform(instance, context);
+		});
+		query = this.orm.preventSelectAll(query);
+		return query;
+	}
+	/**
+	* Create field resolver which will modify query to resolve GraphQL field.
+	*/
+	_getDefaultFieldResolver(field, tableField) {
+		var _this$options$modifie;
+		const tableFieldLookup = tableField || field;
+		if (((_this$options$modifie = this.options.modifiers) === null || _this$options$modifie === void 0 ? void 0 : _this$options$modifie[tableFieldLookup]) || this.virtualFields.has(tableFieldLookup)) return (query) => query;
+		else if (this.relations.has(tableFieldLookup)) return defineRelationResolver({ tableField });
+		else return defineFieldResolver({ tableField });
+	}
 };
-
-// src/orm/orm.ts
-var import_orchid_orm = require("orchid-orm");
-var orm = {
-  Table: void 0,
-  Query: void 0,
-  QueryTransform: void 0,
-  // Reflection
-  get_table_table(table) {
-    return table.table;
-  },
-  get_table_relations(table) {
-    return Object.keys(table.relations);
-  },
-  get_table_virtual_fields() {
-    return [];
-  },
-  get_table_modifiers() {
-    return void 0;
-  },
-  get_query_table(query) {
-    if (!query.table) {
-      throw new Error("Query must have table.");
-    }
-    return query.table;
-  },
-  // Select
-  select_field(query, { field, as }) {
-    return query.select({ [as]: field });
-  },
-  select_relation(query, { relation, as, modify }) {
-    return query.select({
-      [as]: (q) => modify(q[relation])
-    });
-  },
-  // Find
-  where(query, field, op, value) {
-    return query.where({ [field]: op ? { [op]: value } : value });
-  },
-  where_raw(query, expression, bindings) {
-    return query.where((0, import_orchid_orm.raw)({ raw: expression, values: bindings }));
-  },
-  // Order & Limit
-  reset_query_order(query) {
-    return query.clear("order");
-  },
-  add_query_order(query, { field, dir }) {
-    return query.order({ [field]: dir });
-  },
-  get_query_order(query) {
-    return query.q.order?.flatMap((orderItem) => {
-      if (typeof orderItem === "string") {
-        return { field: "orderItem", dir: "ASC" };
-      } else if (typeof orderItem === "object") {
-        return Object.entries(orderItem).map(([field, order]) => {
-          const [dir] = order.split(" ", 1);
-          if (dir === "ASC" || dir === "DESC") {
-            return { field, dir };
-          } else {
-            throw new Error("Unsupported order: " + order);
-          }
-        });
-      } else {
-        throw new TypeError("Unsupported order type: " + orderItem);
-      }
-    }) || [];
-  },
-  set_query_limit(query, limit) {
-    return query.limit(limit);
-  },
-  // Pagination helpers
-  set_query_page_result(query, get_page) {
-    return query.transform((nodes) => get_page(nodes));
-  },
-  modify_subquery_pagination(subquery) {
-    return subquery;
-  },
-  finish_query_pagination(query) {
-    return query;
-  },
-  // Misc
-  run_after_query(query, fn) {
-    return query.afterQuery((data) => fn(data));
-  },
-  prevent_select_all(query) {
-    return query;
-  }
+//#endregion
+//#region src/orm/orm.ts
+const orm = {
+	Table: void 0,
+	Query: void 0,
+	QueryTransform: void 0,
+	getTableName(table) {
+		return table.table;
+	},
+	getTableRelations(table) {
+		return Object.keys(table.relations);
+	},
+	getTableVirtualFields() {
+		return [];
+	},
+	getTableModifiers() {},
+	getQueryTable(query) {
+		if (!query.table) throw new Error("Query must have table.");
+		return query.table;
+	},
+	selectField(query, { field, as }) {
+		return query.select({ [as]: field });
+	},
+	selectRelation(query, { relation, as, modify }) {
+		return query.select({ [as]: (q) => modify(q[relation]) });
+	},
+	where(query, field, op, value) {
+		return query.where({ [field]: op ? { [op]: value } : value });
+	},
+	prepareCursorPagination(query, { cursor, fields, limit }) {
+		if (fields) {
+			query = query.clear("order");
+			for (const { field, dir } of fields) query = query.order({ [field]: dir });
+		}
+		const prepared = (0, orchid_pagination.prepareCursorPagination)(query, { limit }, { cursor });
+		return {
+			query: prepared.query,
+			getPage(nodes) {
+				const page = prepared.finalize(nodes);
+				return {
+					nodes: page.items,
+					cursor: page.nextCursor
+				};
+			}
+		};
+	},
+	setQueryPageResult(query, get_page) {
+		return query.transform((nodes) => get_page(nodes));
+	},
+	modifySubqueryPagination(subquery) {
+		return subquery;
+	},
+	finishQueryPagination(query) {
+		return query;
+	},
+	runAfterQuery(query, fn) {
+		return query.afterQuery((data) => fn(data));
+	},
+	preventSelectAll(query) {
+		return query;
+	}
 };
-
-// src/filter.ts
-function filterQuery2(query, filter, options) {
-  return filterQuery(orm, query, filter, options);
+//#endregion
+//#region src/filter.ts
+function filterQuery(query, filter, options) {
+	return filterQuery$1(orm, query, filter, options);
 }
-
-// src/resolvers/graph.ts
+//#endregion
+//#region src/resolvers/graph.ts
 function createGraphResolver(types, options) {
-  return new OrchidGraphResolver(types, options);
+	return new OrchidGraphResolver(types, options);
 }
 var OrchidGraphResolver = class extends GraphResolver {
-  constructor(types, options = {}) {
-    super(orm, types, options);
-    this.types = types;
-    this.options = options;
-  }
-  resolve(query, options) {
-    return super.resolve(query, options);
-  }
+	types;
+	options;
+	constructor(types, options = {}) {
+		super(orm, types, options);
+		this.types = types;
+		this.options = options;
+	}
+	resolve(query, options) {
+		return super.resolve(query, options);
+	}
 };
-
-// src/resolvers/table.ts
+//#endregion
+//#region src/resolvers/table.ts
 function defineTableResolver(table, options = {}) {
-  return new TableResolver(orm, table, options);
+	return new TableResolver(orm, table, options);
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createGraphResolver,
-  cursor,
-  defineCursorPaginator,
-  defineFieldResolver,
-  definePageResolver,
-  defineRelationResolver,
-  defineTableResolver,
-  field,
-  filterQuery,
-  graph,
-  page,
-  relation,
-  table
-});
+//#endregion
+exports.createGraphResolver = createGraphResolver;
+exports.cursor = defineCursorPaginator;
+exports.defineCursorPaginator = defineCursorPaginator;
+exports.defineFieldResolver = defineFieldResolver;
+exports.definePageResolver = definePageResolver;
+exports.defineRelationResolver = defineRelationResolver;
+exports.defineTableResolver = defineTableResolver;
+exports.field = defineFieldResolver;
+exports.filterQuery = filterQuery;
+exports.graph = createGraphResolver;
+exports.page = definePageResolver;
+exports.relation = defineRelationResolver;
+exports.table = defineTableResolver;
+
 //# sourceMappingURL=index.cjs.map