@dotcms/client 0.0.1-alpha.37 → 0.0.1-alpha.39

package/src/lib/query-builder/lucene-syntax/{NotOperand.d.ts → NotOperand.ts}

@@ -1,22 +1,34 @@
 import { Equals } from './Equals';
+
+import { buildEquals } from '../utils';
+
 /**
  * 'NotOperand' Is a Typescript class that provides the ability to use the NOT operand in the lucene query string.
  *
  * @export
  * @class NotOperand
  */
-export declare class NotOperand {
-    #private;
-    private query;
-    constructor(query: string);
+export class NotOperand {
+    #query = '';
+
+    constructor(private query: string) {
+        this.#query = this.query;
+    }
+
     /**
      * This method appends to the query a term that should be included in the search.
      *
-     * Ex: myValue or "My value"
+     * @example
+     * ```typescript
+     * const notOperand = new NotOperand("+myField");
+     * notOperand.equals("myValue");
+     * ```
      *
      * @param {string} term - The term that should be included in the search.
      * @return {*}  {Equals} - An instance of Equals.
      * @memberof NotOperand
      */
-    equals(term: string): Equals;
+    equals(term: string): Equals {
+        return buildEquals(this.#query, term);
+    }
 }

package/src/lib/query-builder/lucene-syntax/{Operand.d.ts → Operand.ts}

@@ -1,5 +1,8 @@
 import { Equals } from './Equals';
 import { Field } from './Field';
+
+import { buildExcludeField, buildField, buildEquals } from '../utils';
+
 /**
  * 'Operand' Is a Typescript class that provides the ability to use operands in the lucene query string.}
  * An operand is a logical operator used to join two or more conditions in a query.
@@ -7,10 +10,13 @@ import { Field } from './Field';
  * @export
  * @class Operand
  */
-export declare class Operand {
-    #private;
-    private query;
-    constructor(query: string);
+export class Operand {
+    #query = '';
+
+    constructor(private query: string) {
+        this.#query = this.query;
+    }
+
     /**
      * This method appends to the query a term that should be excluded in the search.
      *
@@ -20,7 +26,10 @@ export declare class Operand {
      * @return {*}  {Field} - An instance of a Lucene Field. A field is a key used to search for a specific value in a document.
      * @memberof Operand
      */
-    excludeField(field: string): Field;
+    excludeField(field: string): Field {
+        return buildExcludeField(this.#query, field);
+    }
+
     /**
      * This method appends to the query a field that should be included in the search.
      *
@@ -30,7 +39,10 @@ export declare class Operand {
      * @return {*}  {Field} -  An instance of a Lucene Field. A field is a key used to search for a specific value in a document.
      * @memberof Operand
      */
-    field(field: string): Field;
+    field(field: string): Field {
+        return buildField(this.#query, field);
+    }
+
     /**
      * This method appends to the query a term that should be included in the search.
      *
@@ -40,5 +52,7 @@ export declare class Operand {
      * @return {*}  {Equals} - An instance of Equals.
      * @memberof Operand
      */
-    equals(term: string): Equals;
+    equals(term: string): Equals {
+        return buildEquals(this.#query, term);
+    }
 }

package/src/lib/query-builder/sdk-query-builder.spec.ts

@@ -0,0 +1,159 @@
+import { QueryBuilder } from './sdk-query-builder';
+
+describe('QueryBuilder', () => {
+    let queryBuilder: QueryBuilder;
+
+    beforeEach(() => {
+        queryBuilder = new QueryBuilder();
+    });
+
+    it('should return a query with a simple term', () => {
+        const queryForBlogs = queryBuilder.field('contentType').equals('Blog').build();
+
+        expect(queryForBlogs).toBe('+contentType:Blog');
+    });
+
+    it('should return a query with multiple fields with a simple term ', () => {
+        const queryForBlogsInSuperCoolSite = queryBuilder
+            .field('contentType')
+            .equals('Blog')
+            .field('conhost')
+            .equals('my-super-cool-site')
+            .build();
+
+        expect(queryForBlogsInSuperCoolSite).toBe('+contentType:Blog +conhost:my-super-cool-site');
+    });
+
+    it("should return a query with an 'OR' operand", () => {
+        const queryForBlogsOrArticles = queryBuilder
+            .field('contentType')
+            .equals('Blog')
+            .or()
+            .equals('Article')
+            .build();
+
+        expect(queryForBlogsOrArticles).toBe('+contentType:Blog OR Article');
+    });
+
+    it("should return a query with an 'AND' operand", () => {
+        const queryForBlogsAndArticles = queryBuilder
+            .field('contentType')
+            .equals('Blog')
+            .and()
+            .equals('Article')
+            .build();
+
+        expect(queryForBlogsAndArticles).toBe('+contentType:Blog AND Article');
+    });
+
+    it("should return a query with a 'NOT' operand", () => {
+        const queryForSkiingTripsNotInSwissAlps = queryBuilder
+            .field('summary')
+            .equals('Skiing trip')
+            .not()
+            .equals('Swiss Alps')
+            .build();
+
+        expect(queryForSkiingTripsNotInSwissAlps).toBe('+summary:"Skiing trip" NOT "Swiss Alps"');
+    });
+
+    it('should return a query with an exclusion field', () => {
+        const queryForFootballBlogsWithoutMessi = queryBuilder
+            .field('contentType')
+            .equals('Blog')
+            .field('title')
+            .equals('Football')
+            .excludeField('summary')
+            .equals('Lionel Messi')
+            .build();
+
+        expect(queryForFootballBlogsWithoutMessi).toBe(
+            '+contentType:Blog +title:Football -summary:"Lionel Messi"'
+        );
+    });
+
+    it('should build a raw query from the query builder', () => {
+        const queryForBlogs = queryBuilder
+            .raw('+summary:Snowboard')
+            .not()
+            .equals('Swiss Alps')
+            .field('contentType')
+            .equals('Blog')
+            .build();
+
+        expect(queryForBlogs).toBe('+summary:Snowboard NOT "Swiss Alps" +contentType:Blog');
+    });
+
+    it('should return a query with a raw query appended', () => {
+        const queryForBlogs = queryBuilder
+            .field('contentType')
+            .equals('Blog')
+            .raw('+summary:Snowboard')
+            .not()
+            .equals('Swiss Alps')
+            .build();
+
+        expect(queryForBlogs).toBe('+contentType:Blog +summary:Snowboard NOT "Swiss Alps"');
+    });
+
+    it('should return a query with a raw query created with a queryBuilder appended and a term', () => {
+        const anotherQueryBuilder = new QueryBuilder();
+
+        const snowboardInCanada = anotherQueryBuilder
+            .field('summary')
+            .equals('Snowboard')
+            .field('country')
+            .equals('Canada')
+            .build();
+
+        const queryForBlogs = queryBuilder
+            .field('contentType')
+            .equals('Blog')
+            .raw(snowboardInCanada)
+            .build();
+
+        expect(queryForBlogs).toBe('+contentType:Blog +summary:Snowboard +country:Canada');
+    });
+
+    it('should return a query with all possible combinations', () => {
+        const blogOrActivity = queryBuilder
+            .field('contentType')
+            .equals('Blog')
+            .or()
+            .equals('Activity');
+
+        const customIdSiteOrCoolSite = blogOrActivity
+            .field('conhost')
+            .equals('48190c8c-42c4-46af-8d1a-0cd5db894797')
+            .or()
+            .equals('cool-site');
+
+        const englishAndSpanish = customIdSiteOrCoolSite
+            .field('languageId')
+            .equals('1')
+            .and()
+            .equals('2');
+
+        const notDeleted = englishAndSpanish.field('deleted').equals('false');
+
+        const currentlyWorking = notDeleted.field('working').equals('true');
+
+        const defaultVariant = currentlyWorking.field('variant').equals('default');
+
+        const snowboardOutsideSwissAlps = defaultVariant
+            .field('title')
+            .equals('Snowboard')
+            .excludeField('summary')
+            .equals('Swiss Alps');
+
+        const writtenByJohnDoe = snowboardOutsideSwissAlps.field('authors').equals('John Doe');
+
+        const withoutJaneDoeHelp = writtenByJohnDoe.not().equals('Jane Doe');
+
+        const query = withoutJaneDoeHelp.build();
+
+        expect(query).toBe(
+            '+contentType:Blog OR Activity +conhost:48190c8c-42c4-46af-8d1a-0cd5db894797 OR cool-site +languageId:1 AND 2 +deleted:false +working:true +variant:default +title:Snowboard -summary:"Swiss Alps" +authors:"John Doe" NOT "Jane Doe"'
+        );
+    });
+});

package/src/lib/query-builder/sdk-query-builder.ts

@@ -0,0 +1,87 @@
+import { Equals, Field } from './lucene-syntax/index';
+import { buildExcludeField, buildField, buildRawEquals } from './utils';
+
+/**
+ * 'QueryBuilder' Is a Typescript class that provides the ability to build a query string using the Lucene syntax in a more readable way.
+ * @example
+ * ```ts
+ *  const qb = new QueryBuilder();
+ *  const query = qb
+ *          .field('contentType')
+ *          .equals('Blog')
+ *          .field('conhost')
+ *          .equals('my-super-cool-site')
+ *          .build(); // Output: `+contentType:Blog +conhost:my-super-cool-site"`
+ * ```
+ *
+ * @example
+ * ```ts
+ *  const qb = new QueryBuilder();
+ *  const query = qb
+ *          .field('contentType')
+ *          .equals('Blog')
+ *          .field('title')
+ *          .equals('Football')
+ *          .excludeField('summary')
+ *          .equals('Lionel Messi')
+ *          .build(); // Output: `+contentType:Blog +title:Football -summary:"Lionel Messi"`
+ * ```
+ * @export
+ * @class QueryBuilder
+ */
+export class QueryBuilder {
+    #query = '';
+
+    /**
+     * This method appends to the query a field that should be included in the search.
+     *
+     * @example
+     * ```ts
+     * const qb = new QueryBuilder();
+     * qb.field("+myField: ", "myValue"); // Current query: "+myField: myValue"
+     * ```
+     *
+     * @param {string} field - The field that should be included in the search.
+     * @return {*}  {Field} -  An instance of a Lucene Field. A field is a key used to search for a specific value in a document.
+     * @memberof QueryBuilder
+     */
+    field(field: string): Field {
+        return buildField(this.#query, field);
+    }
+
+    /**
+     * This method appends to the query a field that should be excluded from the search.
+     *
+     * @example
+     * ```ts
+     * const qb = new QueryBuilder();
+     * qb.excludeField("myField").equals("myValue"); // Current query: "-myField: myValue"
+     * ```
+     *
+     * @param {string} field - The field that should be excluded from the search.
+     * @return {*}  {Field} -  An instance of a Lucene Exclude Field. An exclude field is a key used to exclude for a specific value in a document.
+     * @memberof QueryBuilder
+     */
+    excludeField(field: string): Field {
+        return buildExcludeField(this.#query, field);
+    }
+
+    /**
+     * This method allows to pass a raw query string to the query builder.
+     * This raw query should end in Equals.
+     * This method is useful when you want to append a complex query or an already written query to the query builder.
+     *
+     * @example
+     * ```ts
+     * const qb = new QueryBuilder();
+     * qb.raw("+myField: value AND (someOtherValue OR anotherValue)"); // Current query: "+myField: value AND (someOtherValue OR anotherValue)"
+     * ```
+     *
+     * @param {string} query - A raw query string.
+     * @return {*}  {Equals} - An instance of Equals. A term is a value used to search for a specific value in a document.
+     * @memberof QueryBuilder
+     */
+    raw(query: string): Equals {
+        return buildRawEquals(this.#query, query);
+    }
+}

package/src/lib/query-builder/utils/index.ts

@@ -0,0 +1,179 @@
+import { Equals } from '../lucene-syntax/Equals';
+import { Field } from '../lucene-syntax/Field';
+import { NotOperand } from '../lucene-syntax/NotOperand';
+import { Operand } from '../lucene-syntax/Operand';
+
+/**
+ * Enum for common Operands
+ *
+ * @export
+ * @enum {number}
+ */
+export enum OPERAND {
+    OR = 'OR',
+    AND = 'AND',
+    NOT = 'NOT'
+}
+
+/**
+ * This function removes extra spaces from a string.
+ *
+ * @example
+ * ```ts
+ * sanitizeQuery("  my query  "); // Output: "my query"
+ * ```
+ *
+ * @export
+ * @param {string} str
+ * @return {*}  {string}
+ */
+export function sanitizeQuery(str: string): string {
+    return str.replace(/\s{2,}/g, ' ').trim();
+}
+
+/**
+ * This function sanitizes a term by adding quotes if it contains spaces.
+ * In lucene, a term with spaces should be enclosed in quotes.
+ *
+ * @example
+ * ```ts
+ * sanitizePhrases(`my term`); // Output: `"my term"`
+ * sanitizePhrases(`myterm`); // Output: `myterm`
+ * ```
+ *
+ * @export
+ * @param {string} term
+ * @return {*}  {string}
+ */
+export function sanitizePhrases(term: string): string {
+    return term.includes(' ') ? `"${term}"` : term;
+}
+
+/**
+ * This function builds a term to be used in a lucene query.
+ * We need to sanitize the term before adding it to the query.
+ *
+ * @example
+ * ```ts
+ * const equals = buildEquals("+myField: ", "myValue"); // Current query: "+myField: myValue"
+ * ```
+ *
+ * @export
+ * @param {string} query
+ * @param {string} term
+ * @return {*}  {Equals}
+ */
+export function buildEquals(query: string, term: string): Equals {
+    const newQuery = query + sanitizePhrases(term);
+
+    return new Equals(newQuery);
+}
+
+/**
+ * This function builds a term to be used in a lucene query.
+ * We need to sanitize the raw query before adding it to the query.
+ *
+ * @example
+ * ```ts
+ * const query = "+myField: myValue";
+ * const field = buildRawEquals(query, "-myField2: myValue2"); // Current query: "+myField: myValue -myField2: myValue"
+ * ```
+ *
+ * @export
+ * @param {string} query
+ * @param {string} raw
+ * @return {*}  {Equals}
+ */
+export function buildRawEquals(query: string, raw: string): Equals {
+    const newQuery = query + ` ${raw}`;
+
+    return new Equals(sanitizeQuery(newQuery));
+}
+
+/**
+ * This function builds a field to be used in a lucene query.
+ * We need to format the field before adding it to the query.
+ *
+ * @example
+ * ```ts
+ * const field = buildField("+myField: ", "myValue"); // Current query: "+myField: myValue"
+ * ```
+ *
+ * @export
+ * @param {string} query
+ * @param {string} field
+ * @return {*}  {Field}
+ */
+export function buildField(query: string, field: string): Field {
+    const newQuery = query + ` +${field}:`;
+
+    return new Field(newQuery);
+}
+
+/**
+ * This function builds an exclude field to be used in a lucene query.
+ * We need to format the field before adding it to the query.
+ *
+ * @example
+ * ```ts
+ * const query = "+myField: myValue";
+ * const field = buildExcludeField(query, "myField2"); // Current query: "+myField: myValue -myField2:"
+ * ```
+ *
+ * @export
+ * @param {string} query
+ * @param {string} field
+ * @return {*}  {Field}
+ */
+export function buildExcludeField(query: string, field: string): Field {
+    const newQuery = query + ` -${field}:`;
+
+    return new Field(newQuery);
+}
+
+/**
+ * This function builds an operand to be used in a lucene query.
+ * We need to format the operand before adding it to the query.
+ *
+ * @example
+ * <caption>E.g. Using the AND operand</caption>
+ * ```ts
+ * const query = "+myField: myValue";
+ * const field = buildOperand(query, OPERAND.AND); // Current query: "+myField: myValue AND"
+ * ```
+ * @example
+ * <caption>E.g. Using the OR operand</caption>
+ * ```ts
+ * const query = "+myField: myValue";
+ * const field = buildOperand(query, OPERAND.OR); // Current query: "+myField: myValue OR"
+ * ```
+ * @export
+ * @param {string} query
+ * @param {OPERAND} operand
+ * @return {*}  {Operand}
+ */
+export function buildOperand(query: string, operand: OPERAND): Operand {
+    const newQuery = query + ` ${operand} `;
+
+    return new Operand(newQuery);
+}
+
+/**
+ * This function builds a NOT operand to be used in a lucene query.
+ * We need to format the operand before adding it to the query.
+ *
+ * @example
+ * ```ts
+ * const query = "+myField: myValue";
+ * const field = buildNotOperand(query); // Current query: "+myField: myValue NOT"
+ * ```
+ *
+ * @export
+ * @param {string} query
+ * @return {*}  {NotOperand}
+ */
+export function buildNotOperand(query: string): NotOperand {
+    const newQuery = query + ` ${OPERAND.NOT} `;
+
+    return new NotOperand(newQuery);
+}

package/src/lib/utils/graphql/transforms.spec.ts

@@ -0,0 +1,150 @@
+import { graphqlToPageEntity } from './transforms';
+
+const GRAPHQL_RESPONSE_MOCK = {
+    page: {
+        title: 'test2',
+        url: '/test2',
+        seodescription: null,
+        containers: [
+            {
+                path: '//demo.dotcms.com/application/containers/default/',
+                identifier: '69b3d24d-7e80-4be6-b04a-d352d16493ee',
+                containerStructures: [
+                    {
+                        id: '77ec7720-bad8-431c-a0a3-6443fe87af73'
+                    },
+                    {
+                        id: '1e5372c4-9fff-4793-ad8a-a52558d0d395'
+                    },
+                    {
+                        id: '461b6fad-04a8-49ba-b75b-6634799bc289'
+                    },
+                    {
+                        id: '57b4a9de-4765-4c57-8a05-2a0a317ec546'
+                    },
+                    {
+                        id: '342a83bf-040a-45a2-a4bc-defb0f1bf4eb'
+                    },
+                    {
+                        id: '91a955a0-5c97-4fc3-91dd-f894e2f3dc54'
+                    },
+                    {
+                        id: '71ded7c9deb5b05452824bb42b9aa9d5'
+                    },
+                    {
+                        id: '86a06a2e-ba40-43d4-a3ad-3a870d43bfc1'
+                    },
+                    {
+                        id: '7673e601-26d4-4dbc-b6ad-7028599df656'
+                    },
+                    {
+                        id: '313498a4-5b57-4d9e-8d32-ef2d30f9e867'
+                    }
+                ],
+                containerContentlets: [
+                    {
+                        uuid: 'uuid-1562770692396',
+                        contentlets: [
+                            {
+                                identifier: 'd9444fa005a10d555318d8b014e474d4'
+                            }
+                        ]
+                    }
+                ]
+            }
+        ],
+        host: {
+            hostName: 'demo.dotcms.com'
+        },
+        layout: {
+            title: 'default-template'
+        },
+        template: {
+            identifier: '31f4c794-c769-4929-9d5d-7c383408c65c'
+        },
+        urlContentMap: {
+            identifier: '31f4c794-c769-4929-9d5d-7c383408c74d'
+        },
+        viewAs: {
+            mode: 'LIVE'
+        }
+    }
+};
+
+const MOCK_PAGE_ENTITY = {
+    containers: {
+        '//demo.dotcms.com/application/containers/default/': {
+            container: {
+                identifier: '69b3d24d-7e80-4be6-b04a-d352d16493ee',
+                path: '//demo.dotcms.com/application/containers/default/'
+            },
+            containerStructures: [
+                {
+                    id: '77ec7720-bad8-431c-a0a3-6443fe87af73'
+                },
+                {
+                    id: '1e5372c4-9fff-4793-ad8a-a52558d0d395'
+                },
+                {
+                    id: '461b6fad-04a8-49ba-b75b-6634799bc289'
+                },
+                {
+                    id: '57b4a9de-4765-4c57-8a05-2a0a317ec546'
+                },
+                {
+                    id: '342a83bf-040a-45a2-a4bc-defb0f1bf4eb'
+                },
+                {
+                    id: '91a955a0-5c97-4fc3-91dd-f894e2f3dc54'
+                },
+                {
+                    id: '71ded7c9deb5b05452824bb42b9aa9d5'
+                },
+                {
+                    id: '86a06a2e-ba40-43d4-a3ad-3a870d43bfc1'
+                },
+                {
+                    id: '7673e601-26d4-4dbc-b6ad-7028599df656'
+                },
+                {
+                    id: '313498a4-5b57-4d9e-8d32-ef2d30f9e867'
+                }
+            ],
+            contentlets: {
+                'uuid-1562770692396': [
+                    {
+                        identifier: 'd9444fa005a10d555318d8b014e474d4'
+                    }
+                ]
+            }
+        }
+    },
+    layout: {
+        title: 'default-template'
+    },
+    page: {
+        host: {
+            hostName: 'demo.dotcms.com'
+        },
+        seodescription: null,
+        title: 'test2',
+        url: '/test2'
+    },
+    urlContentMap: {
+        identifier: '31f4c794-c769-4929-9d5d-7c383408c74d'
+    },
+    template: {
+        identifier: '31f4c794-c769-4929-9d5d-7c383408c65c'
+    },
+    viewAs: {
+        mode: 'LIVE'
+    }
+};
+
+describe('GraphQL Parser', () => {
+    it('should return the correct page entity', () => {
+        const pageEntity = graphqlToPageEntity(GRAPHQL_RESPONSE_MOCK);
+
+        expect(pageEntity).toEqual(MOCK_PAGE_ENTITY);
+    });
+});