Feat/cs 43919 referenceNotIn and tags query operator

src/lib/query.ts

@@ -298,5 +298,41 @@ export class Query extends BaseQuery {
   referenceIn(key: string, query: Query) {
     this._parameters[key] = { '$in_query': query._parameters }
     return this;
-}
+  }
+
+  /**
+   * @method referenceNotIn
+   * @memberof Query
+   * @description Returns the raw (JSON) query based on the filters applied on Query object.
+   * @example
+   * import contentstack from '@contentstack/delivery-sdk'
+   *
+   * const stack = contentstack.Stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
+   * const query = stack.contentType('contenttype_uid').query().where('title', QueryOperation.EQUALS, 'value');
+   * const entryQuery = await stack.contentType('contenttype_uid').query().referenceNotIn('reference_uid', query).find<TEntry>();
+   *  
+   * @returns {Query}
+   */
+  referenceNotIn(key: string, query: Query) {
+    this._parameters[key] = { '$nin_query': query._parameters }
+    return this;
+  }
+
+  /**
+   * @method tags
+   * @memberof Query
+   * @description Returns the raw (JSON) query based on the filters applied on Query object.
+   * @example
+   * import contentstack from '@contentstack/delivery-sdk'
+   *
+   * const stack = contentstack.Stack({ apiKey: "apiKey", deliveryToken: "deliveryToken", environment: "environment" });
+   * const query = stack.contentType('contenttype_uid').query().where('title', QueryOperation.EQUALS, 'value');
+   * const entryQuery = await stack.contentType('contenttype_uid').query().tags(['tag1']).find<TEntry>();
+   *  
+   * @returns {Query}
+   */
+  tags(values: (string | number | boolean)[]): Query {
+    this._parameters['tags'] = values;
+    return this;
+  }
 }

test/api/entry-queryables.spec.ts

@@ -116,6 +116,32 @@ describe('Query Operators API test cases', () => {
         expect(entryQuery.entries[0].title).toBe('test');
       }
     });
+    it('should return entry for referenceNotIn query', async () => {
+      const query = makeEntries('contenttype_uid').query().where('title', QueryOperation.EQUALS, 'value');
+      const entryQuery = await makeEntries('contenttype_uid').query().referenceNotIn('reference_uid', query).find<TEntry>();
+
+      if (entryQuery.entries) {
+        expect(entryQuery.entries[0]._version).toBeDefined();
+        expect(entryQuery.entries[0].locale).toBeDefined();
+        expect(entryQuery.entries[0].uid).toBeDefined();
+        expect(entryQuery.entries[0].title).not.toBe('test');
+        expect(entryQuery.entries[0].title).toBe('value2');
+        expect(entryQuery.entries[1]._version).toBeDefined();
+        expect(entryQuery.entries[1].locale).toBeDefined();
+        expect(entryQuery.entries[1].uid).toBeDefined();
+        expect(entryQuery.entries[1].title).toBe('value');
+      }
+    });
+
+    it('should return entry if tags are matching', async () => {
+      const query = await makeEntries('contenttype_uid').query().tags(['tag1']).find<TEntry>();
+      if (query.entries) {
+        expect(query.entries[0]._version).toBeDefined();
+        expect(query.entries[0].locale).toBeDefined();
+        expect(query.entries[0].uid).toBeDefined();
+        expect(query.entries[0].title).toBe('value');
+      }
+    });
 });
 
 function makeEntries(contentTypeUid = ''): Entries {

test/unit/entry-queryable.spec.ts

@@ -47,11 +47,24 @@ describe('Query Operators API test cases', () => {
       const query = contentType.Entry().query().equalTo('fieldUID', 'value');
       expect(query._parameters).toStrictEqual({ 'fieldUID': 'value' });
     });
-    it('should return entry for referencedIn query', async () => {
-      const query1 = contentType.Entry().query().containedIn('fieldUID', ['value']);
+    it('should return entry for referenceIn query', async () => {
+      const query1 = contentType.Entry().query().where('fieldUID', QueryOperation.EQUALS, 'value');
       const entryQuery = await contentType.Entry().query().referenceIn('reference_uid', query1);
       if (entryQuery) {
-        expect(entryQuery._parameters).toEqual({ reference_uid: { '$in_query': { fieldUID: { '$in': [ 'value' ] } } } });
+        expect(entryQuery._parameters).toEqual({ reference_uid: { '$in_query': { fieldUID: 'value' } } });
+      }
+    });
+    it('should return entry for referenceNotIn query', async () => {
+      const query1 = contentType.Entry().query().where('fieldUID', QueryOperation.EQUALS, 'value');
+      const entryQuery = await contentType.Entry().query().referenceNotIn('reference_uid', query1);
+      if (entryQuery) {
+        expect(entryQuery._parameters).toEqual({ reference_uid: { '$nin_query': { fieldUID: 'value' } } });
+      }
+    });
+    it('should return entry if tags are matching', async () => {
+      const query =  contentType.Entry().query().tags(['tag1']);
+      if (query) {
+        expect(query._parameters).toEqual({ tags: ['tag1'] });
       }
     });
 });