fix: resolved conflicts

Author: Vikram Kalta

.talismanrc

@@ -1,6 +1,6 @@
 fileignoreconfig:
 - filename: package-lock.json
-  checksum: d388091773e9515cd3c0a5b881644775aa7b8233a405642e49133f296a4ceeeb
+  checksum: c27c6a4629a6b1cec5e01b5db15d0e12646a1250e0cf1292ac58c561e9bc4993
 - filename: test/unit/image-transform.spec.ts
   checksum: 7beabdd07bd35d620668fcd97e1a303b9cbc40170bf3008a376d75ce0895de2a
 - filename: test/utils/mocks.ts

CHANGELOG.md

@@ -1,3 +1,11 @@
+### Version: 4.4.4
+#### Date: January-06-2025
+Enh: Include References on Entry UID
+
+### Version: 4.4.3
+#### Date: November-30-2024
+Fix: regex method fixed for validation
+
 ### Version: 4.4.2
 #### Date: November-16-2024
 Fix: Variants reset issue fix on query call

package-lock.json

@@ -34,10 +34,10 @@
   },
   "dependencies": {
     "@contentstack/core": "^1.1.4",
-    "@contentstack/utils": "^1.3.14",
+    "@contentstack/utils": "^1.3.15",
     "@types/humps": "^2.0.6",
-    "axios": "^1.7.8",
-    "dotenv": "^16.4.5",
+    "axios": "^1.7.9",
+    "dotenv": "^16.4.7",
     "humps": "^2.0.1",
     "path-browserify": "^1.0.1"
   },
@@ -52,7 +52,7 @@
     "@types/node-localstorage": "^1.3.3",
     "axios-mock-adapter": "^1.22.0",
     "babel-jest": "^29.7.0",
-    "esbuild-plugin-file-path-extensions": "^2.1.3",
+    "esbuild-plugin-file-path-extensions": "^2.1.4",
     "ignore-loader": "^0.1.2",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",

package.json

@@ -91,6 +91,33 @@ export class Entry {
     return this;
   }
 
+  /**
+   * @method includeReference
+   * @memberof Entry
+   * @description To include the content of the referred entry in your response,
+   * you need to use the include[] parameter and specify the UID of the reference field as value.
+   * This function sets the include parameter to a reference field UID in the API request.
+   * @example
+   * const stack = contentstack.stack("apiKey", "deliveryKey", "environment");
+   * const query = stack.contentType("contentTypeUid").entry(entry_uid).includeReference("brand").fetch()
+   *
+   * @param {string} referenceFieldUid - UID of the reference field to include.
+   * @returns {Entry} - Returns the Entry instance for chaining.
+   */
+  includeReference(...referenceFieldUid: (string | string[])[]): Entry {
+    if (referenceFieldUid.length) {
+      referenceFieldUid.forEach(value => {
+        if (!Array.isArray(this._queryParams['include[]'])) {
+          this._queryParams['include[]'] = [];
+        }
+        (this._queryParams['include[]'] as string[]).push(...(Array.isArray(value) ? value : [value]));
+      });
+    } else {
+      console.error("Argument should be a String or an Array.");
+    }
+    return this;
+  }
+
   /**
    * @method includeContentType
    * @memberof Entry

src/lib/entry.ts

@@ -3,10 +3,6 @@ import { BaseQuery } from './base-query';
 import { BaseQueryParameters, QueryOperation, QueryOperator, TaxonomyQueryOperation } from './types';
 import { params, queryParams } from './internal-types';
 
-const safePatterns: RegExp[] = [
-  /^[a-zA-Z0-9_.-]+$/, // Alphanumeric with underscores, periods, and dashes
-];
-
 export class Query extends BaseQuery {
   private _contentTypeUid?: string;
 
@@ -34,10 +30,16 @@ export class Query extends BaseQuery {
 
   // Validate if input matches any of the safe, pre-approved patterns
   private isValidRegexPattern(input: string): boolean {
-    if (!this.isValidAlphanumeric(input)) {
-      return false;
+    const validRegex = /^[a-zA-Z0-9|^$.*+?()[\]{}\\-]+$/; // Allow only safe regex characters
+    if (!validRegex.test(input)) {
+        return false;
+    }
+    try {
+        new RegExp(input);
+        return true;
+    } catch (e) {
+        return false;
     }
-    return safePatterns.some(pattern => pattern.test(input));
   }
 
   private isValidValue(value: any[]): boolean {

src/lib/query.ts

@@ -50,6 +50,15 @@ describe('Entry API tests', () => {
     expect(result.created_by).toBeDefined();
     expect(result.updated_by).toBeDefined();
   });
+  it('should check for include reference', async () => {
+    const result = await makeEntry(entryUid).includeReference('author').fetch<TEntry>();
+    expect(result.title).toBeDefined();
+    expect(result.author).toBeDefined();
+    expect(result.title).toBeDefined();
+    expect(result.url).toBeDefined();
+    expect(result._version).toBeDefined();
+    expect(result.publish_details).toBeDefined();
+  });
 });
 function makeEntry(uid = ''): Entry {
   const entry = stack.contentType('author').entry(uid);

test/api/entry.spec.ts

@@ -37,6 +37,13 @@ describe('Entry class', () => {
     expect(entry._queryParams.include_fallback).toBe('true');
   });
 
+  it('should set the include parameter to the given reference field UID', () => {
+    const referenceFieldUid = 'referenceFieldUid';
+    const returnedValue = entry.includeReference(referenceFieldUid);
+    expect(returnedValue).toBeInstanceOf(Entry);
+    expect(entry._queryParams['include[]']).toContain(referenceFieldUid);
+  });
+
   it('should add "include_metadata" in _queryParams when includeMetadata method is called', () => {
     const returnedValue = entry.includeMetadata();
     expect(returnedValue).toBeInstanceOf(Entry);

test/unit/entry.spec.ts

@@ -83,6 +83,82 @@ describe('Query class', () => {
     expect(mainQuery2._parameters).toHaveProperty('$and', [subQuery1._parameters, subQuery2._parameters]);
   });
 
+  it('should result in error when regex method is called with invalid regex', async () => {
+    const regexQuery = getQueryObject(client, 'your-referenced-content-type-uid');
+    expect(() => regexQuery.regex("fieldUid", "[a-z")).toThrow("Invalid regexPattern: Must be a valid regular expression");
+  });
+
+  it('should add a regex parameter to _parameters when regex method is called with valid regex', () => {
+    query.regex('fieldUid', '^ABCXYZ123');
+    expect(query._parameters['fieldUid']).toEqual({ $regex: '^ABCXYZ123' });
+  });
+
+  it('should add a containedIn parameter to _parameters', () => {
+    query.containedIn('fieldUid', ['value1', 'value2']);
+    expect(query._parameters['fieldUid']).toEqual({ '$in': ['value1', 'value2'] });
+  });
+
+  it('should add a notContainedIn parameter to _parameters', () => {
+    query.notContainedIn('fieldUid', ['value1', 'value2']);
+    expect(query._parameters['fieldUid']).toEqual({ '$nin': ['value1', 'value2'] });
+  });
+
+  it('should add an exists parameter to _parameters', () => {
+    query.exists('fieldUid');
+    expect(query._parameters['fieldUid']).toEqual({ '$exists': true });
+  });
+
+  it('should add a notExists parameter to _parameters', () => {
+    query.notExists('fieldUid');
+    expect(query._parameters['fieldUid']).toEqual({ '$exists': false });
+  });
+
+  it('should add an equalTo parameter to _parameters', () => {
+    query.equalTo('fieldUid', 'value');
+    expect(query._parameters['fieldUid']).toEqual('value');
+  });
+
+  it('should add a notEqualTo parameter to _parameters', () => {
+    query.notEqualTo('fieldUid', 'value');
+    expect(query._parameters['fieldUid']).toEqual({ '$ne': 'value' });
+  });
+
+  it('should add a lessThan parameter to _parameters', () => {
+    query.lessThan('fieldUid', 10);
+    expect(query._parameters['fieldUid']).toEqual({ '$lt': 10 });
+  });
+
+  it('should add a lessThanOrEqualTo parameter to _parameters', () => {
+    query.lessThanOrEqualTo('fieldUid', 10);
+    expect(query._parameters['fieldUid']).toEqual({ '$lte': 10 });
+  });
+
+  it('should add a greaterThan parameter to _parameters', () => {
+    query.greaterThan('fieldUid', 10);
+    expect(query._parameters['fieldUid']).toEqual({ '$gt': 10 });
+  });
+
+  it('should add a greaterThanOrEqualTo parameter to _parameters', () => {
+    query.greaterThanOrEqualTo('fieldUid', 10);
+    expect(query._parameters['fieldUid']).toEqual({ '$gte': 10 });
+  });
+
+  it('should add a tags parameter to _parameters', () => {
+    query.tags(['tag1', 'tag2']);
+    expect(query._parameters['tags']).toEqual(['tag1', 'tag2']);
+  });
+
+  it('should add a search parameter to _queryParams', () => {
+    query.search('searchKey');
+    expect(query._queryParams['typeahead']).toEqual('searchKey');
+  });
+
+  it('should provide proper response when find method is called', async () => {
+    mockClient.onGet(`/content_types/contentTypeUid/entries`).reply(200, entryFindMock);
+    const returnedValue = await query.find();
+    expect(returnedValue).toEqual(entryFindMock);
+  });
+
   it('should provide proper response when find method is called', async () => {
     mockClient.onGet(`/content_types/contentTypeUid/entries`).reply(200, entryFindMock);
     const returnedValue = await query.find();