orchid-graphql 1.8.1 → 1.9.1

package/README.md

@@ -45,7 +45,7 @@ const BaseTable = createBaseTable()
 
 class PostTable extends BaseTable {
   readonly table = "post"
-  columns = this.setColumns((t) => ({
+  columns = this.setColumns(t => ({
     id: t.identity().primaryKey(),
     text: t.text(0, 5000),
   }))
@@ -285,8 +285,8 @@ const graph = r.graph(
           // (related table must be also registered in this graph resolver)
           author: true,
           // Modify query when this field is resolved
-          preview: (q) =>
-            q.select({ preview: q.sql<string>`substr(text,1,100)` }),
+          preview: q =>
+            q.select({ preview: q.sql <string>`substr(text,1,100)` }),
           // Same as text: true
           text: r.field(),
           // Custom field resolver
@@ -296,8 +296,8 @@ const graph = r.graph(
           }),
           preview2: r.field({
             // Modify query
-            modify: (q) =>
-              q.select({ preview2: q.sql<string>`substr(text,1,100)` }),
+            modify: q =>
+              q.select({ preview2: q.sql <string>`substr(text,1,100)` }),
             // Post-process selected value
             transform(
               // Selected value

package/dist/index.cjs

@@ -18,8 +18,8 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
-var src_exports = {};
-__export(src_exports, {
+var index_exports = {};
+__export(index_exports, {
   createGraphResolver: () => createGraphResolver,
   cursor: () => defineCursorPaginator,
   defineCursorPaginator: () => defineCursorPaginator,
@@ -28,12 +28,42 @@ __export(src_exports, {
   defineRelationResolver: () => defineRelationResolver,
   defineTableResolver: () => defineTableResolver,
   field: () => defineFieldResolver,
+  filterQuery: () => filterQuery2,
   graph: () => createGraphResolver,
   page: () => definePageResolver,
   relation: () => defineRelationResolver,
   table: () => defineTableResolver
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(index_exports);
+
+// ../base/src/utils/is-plain-object.ts
+function isPlainObject(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 [tableField, op0] = field.split("__");
+      const op = op0?.toLowerCase();
+      query = orm2.where(query, tableField, op, value);
+    }
+  }
+  return query;
+}
 
 // ../base/src/paginators/cursor.ts
 var import_node_buffer = require("buffer");
@@ -59,22 +89,22 @@ var CursorPaginator = class {
     const { args } = context.tree;
     const pageSize = args.take ?? this.pageSize;
     const cursor = args.cursor;
-    const table = orm2.get_query_table(query);
+    const table = orm2.getQueryTable(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 }));
+    })) : orm2.getQueryOrder(query)).map((o) => ({ ...o, alias: "_order_" + o.field }));
     if (this.fields) {
-      query = orm2.reset_query_order(query);
+      query = orm2.resetQueryOrder(query);
       for (const { alias, dir } of orderFields) {
-        query = orm2.add_query_order(query, { field: alias, dir });
+        query = orm2.addQueryOrder(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 });
+      query = orm2.selectField(query, { field, as: alias });
     }
     if (cursor) {
       const parsedCursor = parseCursor(cursor);
@@ -90,9 +120,9 @@ var CursorPaginator = class {
       const bindings = Object.fromEntries(
         orderFields.map(({ alias }, i) => [alias, parsedCursor[i]])
       );
-      query = orm2.where_raw(query, sqlExpr, bindings);
+      query = orm2.whereRaw(query, sqlExpr, bindings);
     }
-    query = orm2.set_query_limit(query, pageSize + 1);
+    query = orm2.setQueryLimit(query, pageSize + 1);
     function createNodeCursor(node) {
       return createCursor(
         orderFields.map(({ field, alias }) => {
@@ -106,7 +136,7 @@ var CursorPaginator = class {
         })
       );
     }
-    return orm2.set_query_page_result(query, (nodes) => {
+    return orm2.setQueryPageResult(query, (nodes) => {
       let cursor2;
       if (nodes.length > pageSize) {
         cursor2 = createNodeCursor(nodes[pageSize - 1]);
@@ -126,8 +156,8 @@ function parseCursor(cursor) {
 }
 
 // ../base/src/utils/run-after.ts
-function run_after_query(orm2, query, transform) {
-  return orm2.run_after_query(query, async (result) => {
+function runAfterQuery(orm2, query, transform) {
+  return orm2.runAfterQuery(query, async (result) => {
     if (Array.isArray(result)) {
       const result1 = await Promise.all(result.map(transform));
       return result1.filter(Boolean);
@@ -140,7 +170,7 @@ function run_after_query(orm2, query, transform) {
 }
 
 // ../base/src/resolvers/field.ts
-function parse_field_options(options) {
+function parseFieldOptions(options) {
   const { tableField, modelField } = options;
   if (tableField && modelField) {
     throw new Error(
@@ -150,19 +180,19 @@ function parse_field_options(options) {
   return { ...options, tableField: tableField || modelField };
 }
 function defineFieldResolver(options = {}) {
-  const { tableField, modify, transform } = parse_field_options(options);
+  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.select_field(query, {
+      query = context.graph.orm.selectField(query, {
         field: tableField || field,
         as: field
       });
     }
     if (transform) {
-      query = run_after_query(context.graph.orm, query, async (instance) => {
+      query = runAfterQuery(context.graph.orm, query, async (instance) => {
         instance[field] = await transform(instance[field], instance, context);
         return instance;
       });
@@ -174,23 +204,23 @@ function defineFieldResolver(options = {}) {
 // ../base/src/resolvers/graph.ts
 var import_graphql_parse_resolve_info = require("graphql-parse-resolve-info");
 var GraphResolver = class {
-  constructor(orm2, type_resolvers, options = {}) {
+  constructor(orm2, typeResolvers, options = {}) {
     this.orm = orm2;
-    this.type_resolvers = type_resolvers;
+    this.typeResolvers = typeResolvers;
     this.options = options;
   }
   resolve(query, { info, ...context }) {
-    const tree = this._get_resolve_tree(info);
-    return this._resolve_type(query, { ...context, tree });
+    const tree = this._getResolveTree(info);
+    return this._resolveType(query, { ...context, tree });
   }
   resolvePage(query, paginator, { info, ...context }) {
-    const tree = this._get_resolve_tree(info);
-    return this._resolve_page(query, paginator, { ...context, tree });
+    const tree = this._getResolveTree(info);
+    return this._resolvePage(query, paginator, { ...context, tree });
   }
-  _get_resolve_tree(info) {
+  _getResolveTree(info) {
     return (0, import_graphql_parse_resolve_info.parseResolveInfo)(info);
   }
-  _resolve_type(query, context) {
+  _resolveType(query, context) {
     let { tree } = context;
     if (context.path) {
       for (const field of context.path) {
@@ -202,11 +232,11 @@ var GraphResolver = class {
       }
     }
     const type = Object.keys(tree.fieldsByTypeName)[0];
-    const type_resolver = this.type_resolvers[type];
-    if (!type_resolver) {
+    const typeResolver = this.typeResolvers[type];
+    if (!typeResolver) {
       throw new Error(`Resolver not found for type ${type}.`);
     }
-    return type_resolver.resolve(query, {
+    return typeResolver.resolve(query, {
       ...context,
       graph: this,
       tree,
@@ -214,11 +244,11 @@ var GraphResolver = class {
       path: void 0
     });
   }
-  _resolve_page(query, paginator, context) {
+  _resolvePage(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 });
+    query = this._resolveType(query, { ...context, path: paginator.path });
     return paginator.paginate(query, {
       ...context,
       graph: this
@@ -228,90 +258,58 @@ var GraphResolver = class {
 
 // ../base/src/resolvers/page.ts
 function definePageResolver(paginator, options = {}) {
-  const { tableField, modify } = parse_field_options(options);
+  const { tableField, modify } = parseFieldOptions(options);
   return function resolve(query, context) {
     const { graph, field } = context;
-    const pagination_context = {};
-    query = graph.orm.select_relation(query, {
+    const paginationContext = {};
+    query = graph.orm.selectRelation(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 = graph._resolvePage(subquery, paginator, context);
+        subquery = graph.orm.modifySubqueryPagination(
           subquery,
-          pagination_context
+          paginationContext
         );
         return subquery;
       }
     });
-    query = graph.orm.finish_query_pagination(query, field, pagination_context);
+    query = graph.orm.finishQueryPagination(query, field, paginationContext);
     return query;
   };
 }
 
 // ../base/src/resolvers/relation.ts
 function defineRelationResolver(options = {}) {
-  const { tableField, filters, modify } = parse_field_options(options);
+  const { tableField, filters, modify } = parseFieldOptions(options);
   return function resolve(query, context) {
     const { graph, field } = context;
-    return graph.orm.select_relation(query, {
+    return graph.orm.selectRelation(query, {
       relation: tableField || field,
       as: field,
       modify(subquery) {
-        subquery = graph._resolve_type(subquery, { ...context, filters });
+        subquery = graph._resolveType(subquery, { ...context, filters });
         return modify ? modify(subquery, context) : subquery;
       }
     });
   };
 }
 
-// ../base/src/utils/is-plain-object.ts
-function is_plain_object(obj) {
-  return typeof obj === "object" && !Array.isArray(obj);
-}
-
-// ../base/src/filters/filters.ts
-function apply_filters(query, { filters, modifiers, context }) {
-  if (!filters) {
-    return query;
-  }
-  const filter_obj = context.tree.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 === void 0) {
-      continue;
-    }
-    if (modifiers?.[field]) {
-      query = modifiers[field](query, value, context);
-    } else {
-      const [table_field, op0] = field.split("__");
-      const op = op0?.toLowerCase();
-      query = context.graph.orm.where(query, table_field, op, value);
-    }
-  }
-  return query;
-}
-
 // ../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 };
+    this.relations = new Set(orm2.getTableRelations(table));
+    this.virtualFields = new Set(orm2.getTableVirtualFields(table));
+    this.modifiers = { ...orm2.getTableModifiers(table), ...options.modifiers };
     const { fields } = options;
     if (fields) {
-      this.table_field_resolvers = Object.keys(fields).reduce((resolvers, field) => {
+      this.tableFieldResolvers = 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;
+        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}.`
@@ -324,22 +322,22 @@ var TableResolver = class {
   }
   // Introspection results
   relations;
-  virtual_fields;
+  virtualFields;
   modifiers;
-  table_field_resolvers;
+  tableFieldResolvers;
   /** 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) {
+    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 ${table_table}, received ${query_table}.`
+        `Mismatching query table for type ${type}: expected ${tableName}, received ${queryTable}.`
       );
     }
-    const allow_all_fields = this.options.allowAllFields ?? graph.options.allowAllFields ?? !this.options.fields;
-    if (!allow_all_fields && !this.table_field_resolvers) {
+    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.`
       );
@@ -349,7 +347,7 @@ var TableResolver = class {
     }
     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);
+      const r = this.tableFieldResolvers?.[field] || (allowAllFields ? this._getDefaultFieldResolver(field) : void 0);
       if (!r) {
         throw new Error(`No field resolver defined for field ${type}.${field}.`);
       }
@@ -357,31 +355,33 @@ var TableResolver = class {
         query = r(query, { ...context, tree: subtree, field });
       }
     }
-    const allow_all_filters = this.options.allowAllFilters ?? graph.options.allowAllFilters;
-    const effective_filters = allow_all_filters ? true : filters;
-    if (effective_filters) {
-      query = apply_filters(query, {
-        filters: effective_filters,
-        modifiers: this.modifiers,
-        context
-      });
+    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) => {
+      query = runAfterQuery(this.orm, query, (instance) => {
         return transform(instance, context);
       });
     }
-    query = this.orm.prevent_select_all(query);
+    query = this.orm.preventSelectAll(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)) {
+  _getDefaultFieldResolver(field, tableField) {
+    const tableFieldLookup = tableField || field;
+    if (this.options.modifiers?.[tableFieldLookup] || this.virtualFields.has(tableFieldLookup)) {
       return (query) => query;
-    } else if (this.relations.has(table_field_lookup)) {
+    } else if (this.relations.has(tableFieldLookup)) {
       return defineRelationResolver({ tableField });
     } else {
       return defineFieldResolver({ tableField });
@@ -396,29 +396,29 @@ var orm = {
   Query: void 0,
   QueryTransform: void 0,
   // 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() {
     return [];
   },
-  get_table_modifiers() {
+  getTableModifiers() {
     return void 0;
   },
-  get_query_table(query) {
+  getQueryTable(query) {
     if (!query.table) {
       throw new Error("Query must have table.");
     }
     return query.table;
   },
   // 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 }) {
     return query.select({
       [as]: (q) => modify(q[relation])
     });
@@ -427,17 +427,17 @@ var orm = {
   where(query, field, op, value) {
     return query.where({ [field]: op ? { [op]: value } : value });
   },
-  where_raw(query, expression, bindings) {
+  whereRaw(query, expression, bindings) {
     return query.where((0, import_orchid_orm.raw)({ raw: expression, values: bindings }));
   },
   // Order & Limit
-  reset_query_order(query) {
+  resetQueryOrder(query) {
     return query.clear("order");
   },
-  add_query_order(query, { field, dir }) {
+  addQueryOrder(query, { field, dir }) {
     return query.order({ [field]: dir });
   },
-  get_query_order(query) {
+  getQueryOrder(query) {
     return query.q.order?.flatMap((orderItem) => {
       if (typeof orderItem === "string") {
         return { field: "orderItem", dir: "ASC" };
@@ -455,28 +455,33 @@ var orm = {
       }
     }) || [];
   },
-  set_query_limit(query, limit) {
+  setQueryLimit(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));
   },
-  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) {
     return query;
   }
 };
 
+// src/filter.ts
+function filterQuery2(query, filter, options) {
+  return filterQuery(orm, query, filter, options);
+}
+
 // src/resolvers/graph.ts
 function createGraphResolver(types, options) {
   return new OrchidGraphResolver(types, options);
@@ -506,6 +511,7 @@ function defineTableResolver(table, options = {}) {
   defineRelationResolver,
   defineTableResolver,
   field,
+  filterQuery,
   graph,
   page,
   relation,