Json field

packages/adapter-knex/lib/adapter-knex.js

@@ -821,12 +821,16 @@ class QueryBuilder {
         whereJoiner(q => {
           // AND/OR need to traverse both side of the query
           let subJoiner;
-          if (path == 'AND') {
+          if (path === 'AND') {
             q.whereRaw('true');
             subJoiner = w => q.andWhere(w);
-          } else {
+          } else if (path === 'OR') {
             q.whereRaw('false');
             subJoiner = w => q.orWhere(w);
+          } else {
+            throw new Error(
+              'Unknown add wheres condition. If you are trying to implement NOT, you are in the right place'
+            );
           }
           where[path].forEach(subWhere =>
             this._addWheres(subJoiner, listAdapter, subWhere, tableAlias)

packages/adapter-mongoose/lib/query-parser.js

@@ -1,6 +1,11 @@
 const { getType, flatten } = require('@open-keystone/utils');
 
-const { simpleTokenizer, relationshipTokenizer, modifierTokenizer } = require('./tokenizers');
+const {
+  simpleTokenizer,
+  relationshipTokenizer,
+  modifierTokenizer,
+  getRelatedListAdapterFromQueryPath,
+} = require('./tokenizers');
 
 // If it's 0 or 1 items, we can use it as-is. Any more needs an $and/$or
 const joinTerms = (matchTerms, joinOp) =>
@@ -43,44 +48,39 @@ function queryParser({ listAdapter, getUID }, query, pathSoFar = [], include) {
       }
     } else if (getType(value) === 'Object') {
       // A relationship query component
-      const { matchTerm, relationshipInfo } = relationshipTokenizer(listAdapter, key, path, getUID);
+      let currentListAdapter;
+      try {
+        currentListAdapter = getRelatedListAdapterFromQueryPath(listAdapter, path);
+      } catch (e) {
+        // If we can't find the list adapter, it's definitely not a relationship
+        return { matchTerm: simpleTokenizer(listAdapter, query, key, path, null) };
+      }
+
+      const fieldAdapter = currentListAdapter.fieldAdapters.find(
+        ({ path, isRelationship }) =>
+          isRelationship && [path, `${path}_every`, `${path}_some`, `${path}_none`].includes(key)
+      );
 
-      // FIXME: This code introduced regressions. We need to add test coverage
-      // to unique exercise this code and verify its behaviour.
-      // // Greatly improve query using indexes
-      // if (
-      //   Object.keys(value).length === 1 &&
-      //   (value.id || value.id_not || value.id_in || value.id_not_in)
-      // ) {
-      //   const { ObjectId } = listAdapter.mongoose.Types;
-      //   const fieldParser = key.split(/(\_some|\_every|\_none)+$/gm);
-      //   const _path = fieldParser[0];
-      //   const filterType = fieldParser.length > 1 ? fieldParser[1] : '_only';
-      //   const queryCondition = {};
-      //   if (value.id) {
-      //     if (['_only', '_some', '_every'].includes(filterType)) {
-      //       queryCondition[_path] = { $eq: ObjectId(value.id) };
-      //     } else if (filterType === '_none') {
-      //       queryCondition[_path] = { $ne: ObjectId(value.id) };
-      //     }
-      //   } else if (value.id_not && ['_only', '_some', '_every', '_none'].includes(filterType)) {
-      //     queryCondition[_path] = { $ne: ObjectId(value.id_not) };
-      //   } else if (value.id_in && ['_only', '_some'].includes(filterType)) {
-      //     queryCondition[_path] = { $in: value.id_in.map(el => ObjectId(el)) };
-      //   } else if (value.id_not_in && ['_only', '_every'].includes(filterType)) {
-      //     queryCondition[_path] = { $not: { $in: value.id_not_in.map(el => ObjectId(el)) } };
-      //   }
-      //   if (Object.keys(queryCondition).length > 0) {
-      //     return { matchTerm: queryCondition };
-      //   }
-      // }
+      if (fieldAdapter) {
+        const { matchTerm, relationshipInfo } = relationshipTokenizer(
+          listAdapter,
+          key,
+          path,
+          getUID,
+          currentListAdapter
+        );
 
-      return {
-        // matchTerm is our filtering expression. This determines if the
-        // parent item is included in the final list
-        matchTerm,
-        relationships: [{ relationshipInfo, ...queryParser({ listAdapter, getUID }, value, path) }],
-      };
+        return {
+          // matchTerm is our filtering expression. This determines if the
+          // parent item is included in the final list
+          matchTerm,
+          relationships: [
+            { relationshipInfo, ...queryParser({ listAdapter, getUID }, value, path) },
+          ],
+        };
+      } else {
+        return { matchTerm: simpleTokenizer(listAdapter, query, key, path, currentListAdapter) };
+      }
     } else {
       // A simple field query component
       return { matchTerm: simpleTokenizer(listAdapter, query, key, path) };

packages/adapter-mongoose/lib/tokenizers.js

@@ -56,8 +56,11 @@ const getRelatedListAdapterFromQueryPath = (listAdapter, queryPath) => {
   return foundListAdapter;
 };
 
-const relationshipTokenizer = (listAdapter, queryKey, path, getUID = cuid) => {
-  const refListAdapter = getRelatedListAdapterFromQueryPath(listAdapter, path);
+const relationshipTokenizer = (listAdapter, queryKey, path, getUID = cuid, refListAdapter) => {
+  if (refListAdapter === undefined) {
+    refListAdapter = getRelatedListAdapterFromQueryPath(listAdapter, path);
+  }
+  if (!refListAdapter) return {};
   const fieldAdapter = refListAdapter.fieldAdapters
     .filter(adapter => adapter.isRelationship)
     .find(({ path }) => [path, `${path}_every`, `${path}_some`, `${path}_none`].includes(queryKey));
@@ -100,8 +103,11 @@ const relationshipTokenizer = (listAdapter, queryKey, path, getUID = cuid) => {
   };
 };
 
-const simpleTokenizer = (listAdapter, query, queryKey, path) => {
-  const refListAdapter = getRelatedListAdapterFromQueryPath(listAdapter, path);
+const simpleTokenizer = (listAdapter, query, queryKey, path, refListAdapter) => {
+  if (refListAdapter === undefined) {
+    refListAdapter = getRelatedListAdapterFromQueryPath(listAdapter, path);
+  }
+  if (!refListAdapter) return;
   const simpleQueryConditions = objMerge(
     refListAdapter.fieldAdapters.map(a => a.getQueryConditions(a.dbPath))
   );
@@ -110,8 +116,11 @@ const simpleTokenizer = (listAdapter, query, queryKey, path) => {
   }
 };
 
-const modifierTokenizer = (listAdapter, query, queryKey, path) => {
-  const refListAdapter = getRelatedListAdapterFromQueryPath(listAdapter, path);
+const modifierTokenizer = (listAdapter, query, queryKey, path, refListAdapter) => {
+  if (refListAdapter === undefined) {
+    refListAdapter = getRelatedListAdapterFromQueryPath(listAdapter, path);
+  }
+  if (!refListAdapter) return;
   const searchFieldName = listAdapter.config.searchField || 'name';
   return {
     // TODO: Implement configurable search fields for lists

packages/adapter-mongoose/tests/query-parser.test.js

@@ -539,7 +539,7 @@ describe('query parser', () => {
       );
 
       expect(queryTree).toMatchObject({
-        relationships: {},
+        relationships: [],
         matchTerm: {
           $and: [
             { $or: [{ name: { $eq: 'foobar' } }, { age: { $eq: 23 } }] },
@@ -548,5 +548,19 @@ describe('query parser', () => {
         },
       });
     });
+
+    test('falls back to simpleTokenizer when path resolution fails in relationship query', () => {
+      const query = {
+        a: { b: 1 },
+      };
+
+      // We expect this NOT to throw, but to fall back to simpleTokenizer
+      // which returns undefined since 'a' is not a field in User list
+      const queryTree = queryParser({ listAdapter, getUID: k => k }, query, ['broken']);
+      expect(queryTree).toMatchObject({
+        relationships: [],
+        matchTerm: undefined,
+      });
+    });
   });
 });

packages/adapter-prisma/lib/adapter-prisma.js

@@ -101,6 +101,8 @@ class PrismaAdapter extends BaseKeystoneAdapter {
       datasources: { [this.provider]: { url: this._url() } },
     });
     this.prisma.DbNull = Prisma.DbNull;
+    this.prisma.JsonNull = Prisma.JsonNull;
+    this.prisma.AnyNull = Prisma.AnyNull;
     await this.prisma.$connect();
   }
 
@@ -506,36 +508,43 @@ class PrismaListAdapter extends BaseListAdapter {
       this.getListAdapterByKey(this.fieldAdaptersByPath[fieldPath].refListKey).processWheres(
         clause
       );
-    const wheres = Object.entries(where).map(([condition, value]) => {
-      if (condition === 'AND' || condition === 'OR') {
-        return { [condition]: value.map(w => this.processWheres(w)) };
-      } else if (
-        this.fieldAdaptersByPath[condition] &&
-        this.fieldAdaptersByPath[condition].isRelationship
-      ) {
-        // Non-many relationship. Traverse the sub-query, using the referenced list as a root.
-        return { [condition]: processRelClause(condition, value) };
-      } else {
-        // See if any of our fields know what to do with this condition
-        let dbPath = condition;
-        let fieldAdapter = this.fieldAdaptersByPath[dbPath];
-        while (!fieldAdapter && dbPath.includes('_')) {
-          dbPath = dbPath.split('_').slice(0, -1).join('_');
-          fieldAdapter = this.fieldAdaptersByPath[dbPath];
-        }
-
-        // FIXME: ask the field adapter if it supports the condition type
-        const supported =
-          fieldAdapter && fieldAdapter.getQueryConditions(fieldAdapter.dbPath)[condition];
-        if (supported) {
-          return supported(value);
+    const wheres = Object.entries(where)
+      .map(([condition, value]) => {
+        if (condition === 'AND' || condition === 'OR') {
+          const processed = value.map(w => this.processWheres(w)).filter(w => w !== undefined);
+          return processed.length > 0 ? { [condition]: processed } : undefined;
+        } else if (
+          this.fieldAdaptersByPath[condition] &&
+          this.fieldAdaptersByPath[condition].isRelationship
+        ) {
+          // Non-many relationship. Traverse the sub-query, using the referenced list as a root.
+          const processed = processRelClause(condition, value);
+          return processed !== undefined ? { [condition]: processed } : undefined;
         } else {
-          // Many relationship
-          const [fieldPath, constraintType] = condition.split('_');
-          return { [fieldPath]: { [constraintType]: processRelClause(fieldPath, value) } };
+          // See if any of our fields know what to do with this condition
+          let dbPath = condition;
+          let fieldAdapter = this.fieldAdaptersByPath[dbPath];
+          while (!fieldAdapter && dbPath.includes('_')) {
+            dbPath = dbPath.split('_').slice(0, -1).join('_');
+            fieldAdapter = this.fieldAdaptersByPath[dbPath];
+          }
+
+          // FIXME: ask the field adapter if it supports the condition type
+          const supported =
+            fieldAdapter && fieldAdapter.getQueryConditions(fieldAdapter.dbPath)[condition];
+          if (supported) {
+            return supported(value);
+          } else {
+            // Many relationship
+            const [fieldPath, constraintType] = condition.split('_');
+            const processed = processRelClause(fieldPath, value);
+            return processed !== undefined
+              ? { [fieldPath]: { [constraintType]: processed } }
+              : undefined;
+          }
         }
-      }
-    });
+      })
+      .filter(w => w !== undefined);
 
     return wheres.length === 0 ? undefined : wheres.length === 1 ? wheres[0] : { AND: wheres };
   }

packages/fields-oembed/src/test-fixtures.js

@@ -2,7 +2,7 @@ const { Text } = require('@open-keystone/fields');
 const path = require('path');
 require('dotenv').config({ path: path.resolve(__dirname, '../.env') });
 
-import { OEmbed, IframelyOEmbedAdapter } from './';
+import { OEmbed } from './';
 
 export const name = 'OEmbed';
 export const type = OEmbed;
@@ -12,7 +12,41 @@ export const supportsUnique = false;
 export const fieldName = 'portfolio';
 export const subfieldName = 'originalUrl';
 
-const iframelyAdapter = new IframelyOEmbedAdapter({
+class MockOEmbedAdapter {
+  constructor({ apiKey, parameters } = {}) {
+    this.apiKey = apiKey;
+    this.parameters = parameters;
+  }
+  fetch(parameters = {}) {
+    return Promise.resolve({
+      type: 'link',
+      version: '1.0',
+      title: 'Mock Title',
+      author_name: 'Mock Author',
+      author_url: 'https://mock.com/author',
+      provider_name: 'Mock Provider',
+      provider_url: 'https://mock.com/provider',
+      cache_age: 3600,
+      thumbnail_url: 'https://mock.com/thumbnail.png',
+      thumbnail_width: 100,
+      thumbnail_height: 100,
+      url: parameters.url,
+      html: '<div>Mock HTML</div>',
+      width: 800,
+      height: 600,
+    });
+  }
+  getAdminViews() {
+    return [];
+  }
+  getViewOptions() {
+    return {
+      clientApiKey: this.apiKey,
+    };
+  }
+}
+
+const iframelyAdapter = new MockOEmbedAdapter({
   apiKey: process.env.IFRAMELY_API_KEY || 'iframely_api_key',
 });
 

packages/fields/package.json

@@ -52,7 +52,11 @@
     "inflection": "^1.13.1",
     "intersection-observer": "0.12.2",
     "lodash.groupby": "^4.6.0",
+    "lodash.isarray": "^4.0.0",
     "lodash.isequal": "^4.5.0",
+    "lodash.isfunction": "^3.0.9",
+    "lodash.isobject": "^3.0.2",
+    "lodash.omit": "^4.18.0",
     "luxon": "^1.27.0",
     "mongoose": "^8.16.0",
     "p-settle": "^4.1.1",

packages/fields/src/index.js

@@ -7,6 +7,7 @@ export { default as Decimal } from './types/Decimal';
 export { default as File } from './types/File';
 export { default as Float } from './types/Float';
 export { default as Integer } from './types/Integer';
+export { default as Json } from './types/Json';
 export { default as Password } from './types/Password';
 export { default as Relationship } from './types/Relationship';
 export { default as Select } from './types/Select';