@dotcms/client 0.0.1-alpha.9 → 0.0.1-beta.10

package/src/lib/client/content/builders/query/utils/index.d.ts

@@ -0,0 +1,142 @@
+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 declare 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 declare function sanitizeQuery(str: string): string;
+/**
+ * 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 declare function sanitizePhrases(term: string): string;
+/**
+ * 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 declare function buildEquals(query: string, term: string): Equals;
+/**
+ * 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 declare function buildRawEquals(query: string, raw: string): Equals;
+/**
+ * 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 declare function buildField(query: string, field: string): Field;
+/**
+ * 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 declare function buildExcludeField(query: string, field: string): Field;
+/**
+ * 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 declare function buildOperand(query: string, operand: OPERAND): Operand;
+/**
+ * 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 declare function buildNotOperand(query: string): NotOperand;

package/src/lib/client/content/content-api.d.ts

@@ -0,0 +1,129 @@
+import { CollectionBuilder } from './builders/collection/collection';
+import { ClientOptions } from '../../deprecated/sdk-js-client';
+/**
+ * Creates a builder to filter and fetch a collection of content items.
+ * @param contentType - The content type to retrieve.
+ * @returns A CollectionBuilder instance for chaining filters and executing the query.
+ * @template T - The type of the content items (defaults to unknown).
+ *
+ * @example Fetch blog posts with async/await
+ * ```typescript
+ * const response = await client.content
+ *     .getCollection<BlogPost>('Blog')
+ *     .limit(10)
+ *     .page(2)
+ *     .sortBy([{ field: 'title', order: 'asc' }])
+ *     .query(q => q.field('author').equals('John Doe'))
+ *     .depth(1)
+ *     .fetch();
+ *
+ * console.log(response.contentlets);
+ * ```
+ *
+ * @example Fetch blog posts with Promise chain
+ * ```typescript
+ * client.content
+ *     .getCollection<BlogPost>('Blog')
+ *     .limit(10)
+ *     .page(2)
+ *     .sortBy([{ field: 'title', order: 'asc' }])
+ *     .query(q => q.field('author').equals('John Doe'))
+ *     .depth(1)
+ *     .fetch()
+ *     .then(response => console.log(response.contentlets))
+ *     .catch(error => console.error(error));
+ * ```
+ *
+ * @example Using a custom type
+ * ```typescript
+ * interface BlogPost {
+ *     summary: string;
+ *     author: string;
+ *     title: string;
+ * }
+ *
+ * const posts = await client.content
+ *     .getCollection<BlogPost>('Blog')
+ *     .limit(10)
+ *     .fetch();
+ *
+ * posts.contentlets.forEach(post => {
+ *     console.log(post.title, post.author, post.summary);
+ * });
+ * ```
+ */
+export declare class Content {
+    #private;
+    /**
+     * Creates an instance of Content.
+     * @param {ClientOptions} requestOptions - The options for the client request.
+     * @param {string} serverUrl - The server URL.
+     */
+    constructor(requestOptions: ClientOptions, serverUrl: string);
+    /**
+     * Takes a content type and returns a builder to filter and fetch the collection.
+     * @param {string} contentType - The content type to get the collection.
+     * @return {CollectionBuilder<T>} CollectionBuilder to filter and fetch the collection.
+     * @template T - Represents the type of the content type to fetch. Defaults to unknown.
+     * @memberof Content
+     *
+     * @example
+     * ```javascript
+     * // Using await and async
+     * const collectionResponse = await client.content
+     *     .getCollection('Blog')
+     *     .limit(10)
+     *     .page(2)
+     *     .sortBy([{ field: 'title', order: 'asc' }])
+     *     .query((queryBuilder) => queryBuilder.field('author').equals('John Doe'))
+     *     .depth(1);
+     * ```
+     * @example
+     * ```javascript
+     * // Using then and catch
+     * client.content
+     *      .getCollection('Blog')
+     *      .limit(10)
+     *      .page(2)
+     *      .sortBy([{ field: 'title', order: 'asc' }])
+     *      .query((queryBuilder) => queryBuilder.field('author').equals('John Doe'))
+     *      .depth(1)
+     *      .then((response) => {
+     *          console.log(response.contentlets);
+     *      })
+     *      .catch((error) => {
+     *          console.error(error);
+     *      });
+     * ```
+     * @example
+     * ```typescript
+     * // Using a specific type for your content
+     *
+     * type Blog = {
+     *     summary: string;
+     *     author: string;
+     *     title: string;
+     * };
+     *
+     * client.content
+     *     .getCollection<Blog>('Blog')
+     *     .limit(10)
+     *     .page(2)
+     *     .sortBy([{ field: 'title', order: 'asc' }])
+     *     .query((queryBuilder) => queryBuilder.field('author').equals('John Doe'))
+     *     .depth(1)
+     *     .then((response) => {
+     *         response.contentlets.forEach((blog) => {
+     *             console.log(blog.title);
+     *             console.log(blog.author);
+     *             console.log(blog.summary);
+     *         });
+     *     })
+     *     .catch((error) => {
+     *         console.error(error);
+     *     });
+     * ```
+     *
+     */
+    getCollection<T = unknown>(contentType: string): CollectionBuilder<T>;
+}

package/src/lib/client/content/shared/const.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Default variant identifier used in the application.
+ */
+export declare const DEFAULT_VARIANT_ID = "DEFAULT";
+/**
+ * Fields that should not be formatted when sanitizing the query.
+ * These fields are essential for maintaining the integrity of the content type.
+ */
+export declare const CONTENT_TYPE_MAIN_FIELDS: string[];
+/**
+ * URL endpoint for the content API search functionality.
+ */
+export declare const CONTENT_API_URL = "/api/content/_search";

package/src/lib/client/content/shared/types.d.ts

@@ -0,0 +1,138 @@
+import { Equals } from '../builders/query/lucene-syntax';
+import { QueryBuilder } from '../builders/query/query';
+/**
+ * Model to sort by fields.
+ */
+export type SortBy = {
+    /**
+     * The field to sort by.
+     */
+    field: string;
+    /**
+     * The order of sorting: 'asc' for ascending, 'desc' for descending.
+     */
+    order: 'asc' | 'desc';
+};
+/**
+ * Callback to build a query.
+ *
+ * @callback BuildQuery
+ * @param {QueryBuilder} qb - The query builder instance.
+ * @returns {Equals} The built query.
+ */
+export type BuildQuery = (qb: QueryBuilder) => Equals;
+/**
+ * Main fields of a Contentlet (Inherited from the Content Type).
+ */
+export interface ContentTypeMainFields {
+    hostName: string;
+    modDate: string;
+    publishDate: string;
+    title: string;
+    baseType: string;
+    inode: string;
+    archived: boolean;
+    ownerName: string;
+    host: string;
+    working: boolean;
+    locked: boolean;
+    stInode: string;
+    contentType: string;
+    live: boolean;
+    owner: string;
+    identifier: string;
+    publishUserName: string;
+    publishUser: string;
+    languageId: number;
+    creationDate: string;
+    url: string;
+    titleImage: string;
+    modUserName: string;
+    hasLiveVersion: boolean;
+    folder: string;
+    hasTitleImage: boolean;
+    sortOrder: number;
+    modUser: string;
+    __icon__: string;
+    contentTypeIcon: string;
+    variant: string;
+}
+/**
+ * The contentlet has the main fields and the custom fields of the content type.
+ *
+ * @template T - The custom fields of the content type.
+ */
+export type Contentlet<T> = T & ContentTypeMainFields;
+/**
+ * Callback for a fulfilled promise.
+ *
+ * @template T - The type of the response.
+ * @callback OnFullfilled
+ * @param {GetCollectionResponse<T>} value - The response value.
+ * @returns {GetCollectionResponse<T> | PromiseLike<GetCollectionResponse<T>> | void} The processed response or a promise.
+ */
+export type OnFullfilled<T> = ((value: GetCollectionResponse<T>) => GetCollectionResponse<T> | PromiseLike<GetCollectionResponse<T>> | void) | undefined | null;
+/**
+ * Callback for a rejected promise.
+ *
+ * @callback OnRejected
+ * @param {GetCollectionError} error - The error object.
+ * @returns {GetCollectionError | PromiseLike<GetCollectionError> | void} The processed error or a promise.
+ */
+export type OnRejected = ((error: GetCollectionError) => GetCollectionError | PromiseLike<GetCollectionError> | void) | undefined | null;
+/**
+ * Response of the get collection method.
+ *
+ * @template T - The type of the contentlet.
+ */
+export interface GetCollectionResponse<T> {
+    /**
+     * The list of contentlets.
+     */
+    contentlets: Contentlet<T>[];
+    /**
+     * The current page number.
+     */
+    page: number;
+    /**
+     * The size of the page.
+     */
+    size: number;
+    /**
+     * The total number of contentlets.
+     */
+    total: number;
+    /**
+     * The fields by which the contentlets are sorted.
+     */
+    sortedBy?: SortBy[];
+}
+/**
+ * Raw response of the get collection method.
+ *
+ * @template T - The type of the contentlet.
+ */
+export interface GetCollectionRawResponse<T> {
+    entity: {
+        jsonObjectView: {
+            /**
+             * The list of contentlets.
+             */
+            contentlets: Contentlet<T>[];
+        };
+        /**
+         * The size of the results.
+         */
+        resultsSize: number;
+    };
+}
+/**
+ * Error object for the get collection method.
+ */
+export interface GetCollectionError {
+    /**
+     * The status code of the error.
+     */
+    status: number;
+    [key: string]: unknown;
+}

package/src/lib/client/content/shared/utils.d.ts

@@ -0,0 +1,20 @@
+/**
+ * @description
+ * Sanitizes the query for the given content type.
+ * It replaces the fields that are not content type fields with the correct format.
+ * Example: +field: -> +contentTypeVar.field:
+ *
+ * @example
+ *
+ * ```ts
+ * const query = '+field: value';
+ * const contentType = 'contentTypeVar';
+ * const sanitizedQuery = sanitizeQueryForContentType(query, contentType); // Output: '+contentTypeVar.field: value'
+ * ```
+ *
+ * @export
+ * @param {string} query - The query string to be sanitized.
+ * @param {string} contentType - The content type to be used for formatting the fields.
+ * @returns {string} The sanitized query string.
+ */
+export declare function sanitizeQueryForContentType(query: string, contentType: string): string;

package/src/lib/client/models/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * A record of HTTP status codes and their corresponding error messages.
+ *
+ * @type {Record<number, string>}
+ * @property {string} 401 - Unauthorized. Check the token and try again.
+ * @property {string} 403 - Forbidden. Check the permissions and try again.
+ * @property {string} 404 - Not Found. Check the URL and try again.
+ * @property {string} 500 - Internal Server Error. Try again later.
+ * @property {string} 502 - Bad Gateway. Try again later.
+ * @property {string} 503 - Service Unavailable. Try again later.
+ */
+export declare const ErrorMessages: Record<number, string>;