orchid-graphql 1.9.0 → 2.0.0

package/package.json

@@ -1,54 +1,63 @@
 {
   "name": "orchid-graphql",
   "type": "module",
-  "version": "1.9.0",
+  "version": "2.0.0",
   "description": "orchid-orm plugin: resolve GraphQL query with Orchid ORM",
   "author": "Ilya Semenov",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/IlyaSemenov/orchid-graphql"
+    "url": "git+https://github.com/IlyaSemenov/graphql-orm.git",
+    "directory": "packages/orchid"
   },
+  "sideEffects": false,
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
+      "import": "./dist/index.mjs",
       "require": "./dist/index.cjs"
-    }
+    },
+    "./package.json": "./package.json"
   },
-  "main": "dist/index.cjs",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.cts",
   "files": [
     "dist",
     "src"
   ],
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
   "engines": {
     "node": ">=14"
   },
+  "scripts": {
+    "dev": "vite-node --watch playground/readme.sample.ts",
+    "build": "tsdown",
+    "test": "vitest run && tsc --noEmit && tstyche --target 6.0.3",
+    "prepublishOnly": "bun run build"
+  },
   "peerDependencies": {
     "graphql": "^16",
-    "orchid-orm": "^1.31.5"
+    "orchid-orm": "^1.51.0"
   },
   "dependencies": {
-    "graphql-parse-resolve-info": "^4.13.0"
+    "graphql-parse-resolve-info": "^4.13.0",
+    "orchid-pagination": "^2.4.2"
   },
   "devDependencies": {
     "@apollo/server": "^4.7.1",
     "graphql": "^16.6.0",
     "graphql-request": "^6.0.0",
     "graphql-tag": "^2.12.6",
-    "orchid-orm": "^1.31.5",
+    "orchid-orm": "~1.78.5",
+    "postgres": "^3.4.9",
     "tsconfig-vite-node": "^1.1.2",
     "tstyche": "^4.3.0",
-    "tsup": "^8.5.0",
     "vite": "^7.0.5",
     "vite-node": "^3.2.4",
     "vite-tsconfig-paths": "^5.1.4",
-    "vitest": "^3.2.4",
-    "graphql-orm": "1.6.0"
-  },
-  "scripts": {
-    "dev": "vite-node --watch playground/readme.sample.ts",
-    "build": "tsup",
-    "test": "vitest run && tsc --noEmit && tstyche"
+    "vitest": "^3.2.4"
   }
-}
+}

package/src/orm/orm.ts

@@ -1,6 +1,6 @@
-import type { OrmAdapter, SortOrder } from "graphql-orm"
-import type { Query, SelectQueryData, Table } from "orchid-orm"
-import { raw } from "orchid-orm"
+import type { OrmAdapter } from "graphql-orm"
+import type { Query, Table } from "orchid-orm"
+import { prepareCursorPagination as prepareOrchidCursorPagination } from "orchid-pagination"
 
 export type OrchidOrm = OrmAdapter<
 	Table,
@@ -16,24 +16,24 @@ export const orm: OrchidOrm = {
 
 	// Reflection
 
-	get_table_table(table) {
+	getTableName(table) {
 		return table.table!
 	},
 
-	get_table_relations(table) {
+	getTableRelations(table) {
 		return Object.keys(table.relations)
 	},
 
-	get_table_virtual_fields() {
+	getTableVirtualFields() {
 		// Not supported by Orchid.
 		return []
 	},
 
-	get_table_modifiers() {
+	getTableModifiers() {
 		return undefined
 	},
 
-	get_query_table(query) {
+	getQueryTable(query) {
 		if (!query.table) {
 			throw new Error("Query must have table.")
 		}
@@ -42,11 +42,11 @@ export const orm: OrchidOrm = {
 
 	// Select
 
-	select_field(query, { field, as }) {
+	selectField(query, { field, as }) {
 		return query.select({ [as]: field })
 	},
 
-	select_relation(query, { relation, as, modify }) {
+	selectRelation(query, { relation, as, modify }) {
 		// as any casts needed in orchid-orm 1.31+
 		return query.select({
 			[as]: (q: any) => modify(q[relation]),
@@ -59,66 +59,48 @@ export const orm: OrchidOrm = {
 		return query.where({ [field]: op ? { [op]: value } : value })
 	},
 
-	where_raw(query, expression, bindings) {
-		return query.where(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 })
-	},
+	// Pagination helpers
 
-	get_query_order(query) {
-		return (
-			(query.q as SelectQueryData).order?.flatMap<SortOrder>((orderItem) => {
-				if (typeof orderItem === "string") {
-					return { field: "orderItem", dir: "ASC" }
-				} else if (typeof orderItem === "object") {
-					return Object.entries(orderItem).map<SortOrder>(([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)
-				}
-			}) || []
+	prepareCursorPagination(query, { cursor, fields, limit }) {
+		if (fields) {
+			query = query.clear("order")
+			for (const { field, dir } of fields) {
+				query = query.order({ [field]: dir })
+			}
+		}
+		const prepared = prepareOrchidCursorPagination(
+			query as never,
+			{ limit },
+			{ cursor },
 		)
+		return {
+			query: prepared.query,
+			getPage(nodes) {
+				const page = prepared.finalize(nodes as never)
+				return { nodes: page.items, cursor: page.nextCursor }
+			},
+		}
 	},
 
-	set_query_limit(query, limit) {
-		return query.limit(limit)
-	},
-
-	// Pagination helpers
-
-	set_query_page_result(query, get_page) {
+	setQueryPageResult(query, get_page) {
 		return query.transform(nodes => get_page(nodes as any))
 	},
 
-	modify_subquery_pagination(subquery) {
+	modifySubqueryPagination(subquery) {
 		return subquery
 	},
 
-	finish_query_pagination(query) {
+	finishQueryPagination(query) {
 		return query
 	},
 
 	// Misc
 
-	run_after_query(query, fn) {
+	runAfterQuery(query, fn) {
 		return query.afterQuery(data => fn(data))
 	},
 
-	prevent_select_all(query) {
+	preventSelectAll(query) {
 		// Not needed in Orchid
 		return query
 	},

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2023 Ilya Semenov
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/dist/index.d.ts

@@ -1,192 +0,0 @@
-import { GraphQLResolveInfo } from 'graphql';
-import { ResolveTree } from 'graphql-parse-resolve-info';
-import { Table, Query } from 'orchid-orm';
-
-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, TableFilterModifier<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;
-}
-type TableFilterModifier<Orm extends OrmAdapter, Context> = FilterModifier$1<Orm, TableResolveContext<Orm, Context>>;
-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, TableFilterModifier<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 GraphResolverOptions<Orm extends OrmAdapter, Context> = Pick<TableResolverOptions<Orm, Context>, "allowAllFields" | "allowAllFilters">;
-interface GraphResolveOptions<Context> {
-    info: GraphQLResolveInfo;
-    context: Context;
-    filters?: FilterConfig;
-    /** 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<T>(query: Orm["Query"], { info, ...context }: GraphResolveOptions<Context>): Promise<T>;
-    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"];
-    _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 SortOrder {
-    field: string;
-    dir: "ASC" | "DESC";
-}
-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, order: SortOrder): Query;
-    get_query_order(query: Query): SortOrder[];
-    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;
-}
-
-type FilterConfig = boolean;
-type FieldFilterScalarValue = null | string | number | boolean;
-type FieldFilterValue = FieldFilterScalarValue | Exclude<FieldFilterScalarValue, null>[];
-type FilterValue = {
-    [property: string]: FieldFilterValue;
-};
-type FilterQueryOptions$1<Orm extends OrmAdapter, Context = unknown> = {
-    modifiers?: FilterModifiers$1<Orm, Context>;
-} & (Context extends undefined ? {
-    context?: Context;
-} : {
-    context: Context;
-});
-type FilterModifier$1<Orm extends OrmAdapter, Context> = (query: Orm["Query"], value: any, context: Context) => Orm["Query"];
-type FilterModifiers$1<Orm extends OrmAdapter, Context> = Record<string, FilterModifier$1<Orm, Context>>;
-
-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 pageSize: number;
-    readonly fields?: Array<{
-        name: string;
-        desc: boolean;
-    }>;
-    constructor(options?: CursorPaginatorOptions);
-    paginate(query: Orm["Query"], context: PaginateContext<Orm, Context>): any;
-}
-
-interface RelationResolverOptions<Orm extends OrmAdapter, Context> extends Omit<FieldResolverOptions<Orm, Context>, "modify"> {
-    filters?: FilterConfig;
-    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<Table, Query, Pick<Promise<any>, "then" | "catch">>;
-
-type FilterQueryOptions<Context = undefined> = FilterQueryOptions$1<OrchidOrm, Context>;
-type FilterModifier<Context = undefined> = FilterModifier$1<OrchidOrm, Context>;
-type FilterModifiers<Context = undefined> = FilterModifiers$1<OrchidOrm, Context>;
-declare function filterQuery<Q extends Query, Context = undefined>(query: Q, filter: FilterValue, options?: FilterQueryOptions<Context>): Q;
-
-declare function createGraphResolver<Context = unknown>(types: Record<string, TableResolver<OrchidOrm, Context>>, options?: GraphResolverOptions<OrchidOrm, Context>): OrchidGraphResolver<Context>;
-declare class OrchidGraphResolver<Context> extends GraphResolver<OrchidOrm, Context> {
-    readonly types: Record<string, TableResolver<OrchidOrm, Context>>;
-    readonly options: GraphResolverOptions<OrchidOrm, Context>;
-    constructor(types: Record<string, TableResolver<OrchidOrm, Context>>, options?: GraphResolverOptions<OrchidOrm, Context>);
-    resolve<T>(query: Query & {
-        returnType: unknown extends T ? any : T extends unknown[] ? undefined | "all" : T extends undefined ? "one" : "oneOrThrow";
-    }, options: GraphResolveOptions<Context>): Promise<T>;
-}
-
-declare function defineTableResolver<Context = unknown>(table: Table, options?: TableResolverOptions<OrchidOrm, Context>): TableResolver<OrchidOrm, Context>;
-
-export { type FilterModifier, type FilterModifiers, type FilterQueryOptions, type FilterValue, createGraphResolver, defineCursorPaginator as cursor, defineCursorPaginator, defineFieldResolver, definePageResolver, defineRelationResolver, defineTableResolver, defineFieldResolver as field, filterQuery, createGraphResolver as graph, definePageResolver as page, defineRelationResolver as relation, defineTableResolver as table };