orchid-graphql 0.0.3 → 1.0.0

package/dist/index.js

@@ -1,26 +1,4 @@
-// src/paginators/base.ts
-var s = Symbol();
-function set_query_page_result(query, get_page) {
-  function _get_page(data) {
-    if (!Array.isArray(data)) {
-      throw new Error(`Paginator called for single result query.`);
-    }
-    return get_page(data);
-  }
-  const _query = query.query;
-  const { handleResult } = _query;
-  _query.handleResult = (q, result, s2) => {
-    const data = handleResult(q, result, s2);
-    return s2 ? data : _get_page(data);
-  };
-  _query[s] = _get_page;
-  return query;
-}
-function get_query_pagination_handler(query) {
-  return query.query[s];
-}
-
-// src/paginators/cursor.ts
+// ../graphql-orm-resolver/src/paginators/cursor.ts
 function defineCursorPaginator(options = {}) {
   return new CursorPaginator(options);
 }
@@ -42,18 +20,22 @@ var CursorPaginator = class {
       }
     });
   }
-  paginate(query, args = {}) {
+  paginate(query, context) {
+    const { orm: orm2 } = context.graph;
+    const { args } = context.tree;
     const take = args.take ?? this.options.take;
-    const { cursor } = args;
-    query = query.clear("order");
+    const cursor = args.cursor;
+    query = orm2.reset_query_order(query);
     for (const field of this.fields) {
-      query = query.select(field.name).order({ [field.name]: field.desc ? "DESC" : "ASC" });
+      query = orm2.select_field(query, { field: field.name, as: field.name });
+      query = orm2.add_query_order(query, field.name, field.desc);
     }
     if (cursor) {
-      query = this._set_query_cursor(query, cursor);
+      const { expression, bindings } = this._parse_cursor(cursor);
+      query = orm2.where_raw(query, expression, bindings);
     }
-    query = query.limit(take + 1);
-    query = set_query_page_result(query, (nodes) => {
+    query = orm2.set_query_limit(query, take + 1);
+    query = orm2.set_query_page_result(query, (nodes) => {
       let cursor2;
       if (nodes.length > take) {
         cursor2 = this._create_cursor(nodes[take - 1]);
@@ -76,39 +58,29 @@ var CursorPaginator = class {
       })
     );
   }
-  _set_query_cursor(query, cursor) {
+  _parse_cursor(cursor) {
     const values = JSON.parse(cursor);
     const left = [];
     const right = [];
-    const expr_values = {};
+    const bindings = {};
     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];
+      placeholders.push("$" + field.name);
+      bindings[field.name] = values[i];
     }
-    return query.where(
-      query.raw(`(${left.join(",")}) > (${right.join(",")})`, expr_values)
-    );
+    return {
+      expression: `(${left.join(",")}) > (${right.join(",")})`,
+      bindings
+    };
   }
 };
 
-// src/utils/query-context.ts
-var graphql = Symbol("graphql");
-function set_query_context(query, context) {
-  ;
-  query.query[graphql] = context;
-}
-function get_query_context(query) {
-  return query.query[graphql];
-}
-
-// src/utils/run-after.ts
-function run_after_query(query, transform) {
-  return query.afterQuery(async (_, result) => {
+// ../graphql-orm-resolver/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);
@@ -120,19 +92,21 @@ function run_after_query(query, transform) {
   });
 }
 
-// src/resolvers/field.ts
+// ../graphql-orm-resolver/src/resolvers/field.ts
 function defineFieldResolver(options = {}) {
   const { tableField, modify, transform } = options;
-  return function resolve(query, options2) {
-    const { field } = options2;
+  return function resolve(query, context) {
+    const { field } = context;
     if (modify) {
-      return modify(query, options2);
+      query = modify(query, context);
     } else {
-      query = query.select({ [field]: tableField || field });
+      query = context.graph.orm.select_field(query, {
+        field: tableField || field,
+        as: field
+      });
     }
     if (transform) {
-      const context = get_query_context(query);
-      query = run_after_query(query, async (instance) => {
+      query = run_after_query(context.graph.orm, query, async (instance) => {
         instance[field] = await transform(instance[field], instance, context);
         return instance;
       });
@@ -141,118 +115,103 @@ function defineFieldResolver(options = {}) {
   };
 }
 
-// src/resolvers/graph.ts
+// ../graphql-orm-resolver/src/resolvers/graph.ts
 import { parseResolveInfo } from "graphql-parse-resolve-info";
-function createGraphResolver(types, options) {
-  return new GraphResolver(types, options);
-}
 var GraphResolver = class {
-  constructor(tables, options = {}) {
-    this.tables = tables;
+  constructor(orm2, type_resolvers, options = {}) {
+    this.orm = orm2;
+    this.type_resolvers = type_resolvers;
     this.options = options;
   }
   resolve(query, { info, context, filters }) {
-    set_query_context(query, context);
     const tree = this._get_resolve_tree(info);
-    return this._resolve_type({ query, tree, filters });
+    return this._resolve_type(query, { tree, filters, context });
   }
   resolvePage(query, paginator, { info, context, filters }) {
-    set_query_context(query, context);
     const tree = this._get_resolve_tree(info);
-    return this._resolve_page({ query, tree, paginator, filters });
+    return this._resolve_page(query, paginator, { tree, filters, context });
   }
   _get_resolve_tree(info) {
     return parseResolveInfo(info);
   }
-  _resolve_type({
-    tree,
-    query,
-    filters
-  }) {
+  _resolve_type(query, context) {
+    const { tree } = context;
     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}.`);
+    const type_resolver = this.type_resolvers[type];
+    if (!type_resolver) {
+      throw new Error(`Resolver not found for type ${type}.`);
     }
-    return table_resolver({ tree, type, query, filters, graph: this });
+    return type_resolver.resolve(query, {
+      ...context,
+      graph: this,
+      tree,
+      type
+    });
   }
-  _resolve_page({
-    tree,
-    query,
-    paginator,
-    filters
-  }) {
-    const { args } = tree;
+  _resolve_page(query, paginator, context) {
+    let { tree } = context;
     for (const field of paginator.path) {
       const type = Object.keys(tree.fieldsByTypeName)[0];
       tree = tree.fieldsByTypeName[type][field];
     }
-    query = this._resolve_type({ query, tree, filters });
-    return paginator.paginate(query, args);
+    query = this._resolve_type(query, { ...context, tree });
+    return paginator.paginate(query, {
+      ...context,
+      graph: this
+    });
   }
 };
 
-// src/resolvers/page.ts
-import { overrideParserInQuery } from "orchid-core";
+// ../graphql-orm-resolver/src/resolvers/page.ts
 function definePageResolver(paginator, options = {}) {
-  const { tableField, filters, modify } = options;
-  return defineFieldResolver({
-    modify: (query, { field, tree, graph }) => {
-      let get_page;
-      query = query.select({
-        [field]: (q) => {
-          q = graph._resolve_page({
-            tree,
-            query: q[tableField || field],
-            paginator,
-            filters
-          });
-          get_page = get_query_pagination_handler(q);
-          return modify ? modify(q, tree) : q;
-        }
-      });
-      overrideParserInQuery(query.query, field, get_page);
-      return query;
-    }
-  });
+  const { tableField, modify } = 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 = graph._resolve_page(subquery, paginator, context);
+        subquery = graph.orm.modify_subquery_pagination(
+          subquery,
+          pagination_context
+        );
+        return modify ? modify(subquery, context) : subquery;
+      }
+    });
+    query = graph.orm.finish_query_pagination(query, field, pagination_context);
+    return query;
+  };
 }
 
-// src/resolvers/relation.ts
+// ../graphql-orm-resolver/src/resolvers/relation.ts
 function defineRelationResolver(options = {}) {
   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[tableField || field],
-          filters
-        });
-        return modify ? modify(relation_query, tree) : relation_query;
+  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;
       }
-    })
-  });
+    });
+  };
 }
 
-// src/utils/is-plain-object.ts
+// ../graphql-orm-resolver/src/utils/is-plain-object.ts
 function is_plain_object(obj) {
   return typeof obj === "object" && !Array.isArray(obj);
 }
 
-// src/filters/filters.ts
-function is_scalar(value) {
-  return value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
-}
-function apply_filters({
-  query,
-  filters,
-  args,
-  modifiers
-}) {
+// ../graphql-orm-resolver/src/filters/filters.ts
+function apply_filters(query, { filters, modifiers, context }) {
   if (!filters) {
     return query;
   }
-  const filter_obj = args?.filter;
+  const filter_obj = context.tree.args?.filter;
   if (!filter_obj) {
     return query;
   }
@@ -264,122 +223,196 @@ function apply_filters({
       continue;
     }
     if (modifiers?.[field]) {
-      query = modifiers[field](query, value);
+      query = modifiers[field](query, value, context);
     } else {
-      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}.`
-        );
-      }
+      const [table_field, op0] = field.split("__");
+      const op = op0?.toLowerCase();
+      query = context.graph.orm.where(query, table_field, op, value);
     }
   }
   return query;
 }
 
-// src/resolvers/table.ts
-function defineTableResolver(table, options = {}) {
-  const get_default_field_resolver = (field, tableField) => {
-    const table_field_lookup = tableField || field;
-    if (options.modifiers?.[table_field_lookup]) {
-      return (query) => query;
-    } else if (table.relations?.[table_field_lookup]) {
-      return defineRelationResolver({ tableField });
-    } else {
-      return defineFieldResolver({ tableField });
+// ../graphql-orm-resolver/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;
+      }, {});
     }
-  };
-  const { fields } = options;
-  const table_field_resolvers = fields ? Object.keys(fields).reduce(
-    (resolvers, field) => {
-      const r0 = fields[field];
-      const r = typeof r0 === "function" ? r0 : r0 === true ? get_default_field_resolver(field) : typeof r0 === "string" ? 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 ${r0}`
-        );
-      }
-      resolvers[field] = r;
-      return resolvers;
-    },
-    {}
-  ) : void 0;
-  const { modify, transform } = options;
-  return function resolve({ tree, type, query, filters, graph }) {
-    if (query.table !== table.table) {
+  }
+  // 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 type (expected ${table.table}, found ${query.table}).`
+        `Mismatching query table for type ${type}: expected ${table_table}, received ${query_table}.`
       );
     }
-    const allow_all_fields = options.allowAllFields ?? graph.options.allowAllFields ?? table_field_resolvers === void 0;
-    if (!allow_all_fields && !table_field_resolvers) {
+    const allow_all_fields = this.options.allowAllFields ?? graph.options.allowAllFields ?? !this.options.fields;
+    if (!allow_all_fields && !this.table_field_resolvers) {
       throw new Error(
-        `Table resolver for ${type} must either allow all fields or specify options.fields`
+        `Resolver for type ${type} must either allow all fields or specify options.fields.`
       );
     }
     if (modify) {
-      query = modify(query, tree);
+      query = modify(query, context);
     }
     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) : void 0);
+      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}`);
+        throw new Error(`No field resolver defined for field ${type}.${field}.`);
       }
       if (r) {
-        query = r(query, { field, tree: subtree, graph });
+        query = r(query, { ...context, tree: subtree, field });
       }
     }
-    const allow_all_filters = options.allowAllFilters ?? graph.options.allowAllFilters;
+    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,
+      query = apply_filters(query, {
         filters: effective_filters,
-        args: tree.args,
-        modifiers: options.modifiers
+        modifiers: this.modifiers,
+        context
       });
     }
     if (transform) {
-      const context = get_query_context(query);
-      query = run_after_query(query, (instance) => {
+      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 });
+    }
+  }
+};
+
+// src/orm/orm.ts
+import { overrideParserInQuery } from "orchid-core";
+var orm = {
+  // 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(query.raw(expression, bindings));
+  },
+  // Order & Limit
+  reset_query_order(query) {
+    return query.clear("order");
+  },
+  add_query_order(query, field, desc) {
+    return query.order({ [field]: desc ? "DESC" : "ASC" });
+  },
+  set_query_limit(query, limit) {
+    return query.limit(limit);
+  },
+  // Pagination helpers
+  set_query_page_result(query, get_page) {
+    const _query = query.query;
+    const { handleResult } = _query;
+    _query.handleResult = (q, result, s2) => {
+      const data = handleResult(q, result, s2);
+      return s2 ? data : get_page(data);
+    };
+    _query[s] = get_page;
+    return query;
+  },
+  modify_subquery_pagination(subquery, context) {
+    context.get_page = subquery.query[s];
+    return subquery;
+  },
+  finish_query_pagination(query, field, context) {
+    const { get_page } = context;
+    if (!get_page) {
+      throw new Error(`Internal error: paginator didn't provide page callback.`);
+    }
+    overrideParserInQuery(query.query, field, get_page);
+    return query;
+  },
+  // Misc
+  run_after_query(query, fn) {
+    return query.afterQuery(async (_, result) => fn(result));
+  },
+  prevent_select_all(query) {
+    return query;
+  }
+};
+var s = Symbol("subquery_pagination_handler");
+
+// src/resolvers/graph.ts
+function createGraphResolver(types, options) {
+  return new GraphResolver(orm, types, options);
+}
+
+// src/resolvers/table.ts
+function defineTableResolver(table, options = {}) {
+  return new TableResolver(orm, table, options);
 }
 export {
   createGraphResolver,