@querc/squidex-client/dist/schemas/content.js

NodeJS client for the [Squidex](https://squidex.io/) CMS

"use strict";

Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.ContentSchema = void 0;

var _squidexQuery = require("./squidex-query");

function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }

class ContentSchema {
  constructor(config, httpClient, authenticationManager) {
    this.config = config;
    this.httpClient = httpClient;
    this.authenticationManager = authenticationManager;

    _defineProperty(this, "schema", void 0);
  }
  /**
   * Returns all content from the API matching `query`
   * Set `draft` to true to return content in draft
   * */


  async query(query = {}, draft = false) {
    const token = await this.authenticationManager.authenticate();
    const path = this.buildPath('', query);
    const response = await this.httpClient.send({
      method: 'GET',
      path,
      token,
      draft
    });
    response.items = response.items.map(x => {
      return this.convertFromJson(x);
    });
    return response;
  }
  /**
   * Returns the first content item from the API matching `query`
   * Set `draft` to true to return content in draft
   * */


  async querySingle(query = {}, draft = false) {
    if (!(query instanceof _squidexQuery.SquidexJsonQuery)) {
      query.$top = 1;
    }

    const response = await this.query(query, draft);
    return response.items[0];
  }
  /**
   * Creates a new content item
   *
   * @param publish whether to publish the content item immediately
   */


  async create(content, publish = false) {
    const token = await this.authenticationManager.authenticate();
    const path = this.buildPath('', {
      publish
    });
    const response = await this.httpClient.send({
      method: 'POST',
      path,
      token,
      data: content
    });
    return this.convertFromJson(response);
  }
  /**
   * Updates a content item
   *
   * @param id ID of the content item
   */


  async update(id, content) {
    const token = await this.authenticationManager.authenticate();
    const path = this.buildPath(id);
    const response = await this.httpClient.send({
      method: 'PUT',
      path,
      token,
      data: content
    });
    return this.convertFromJson(response);
  }
  /**
   * Patches a content item
   *
   * @param id ID of the content item
   */


  async patch(id, content) {
    const token = await this.authenticationManager.authenticate();
    const path = this.buildPath(id);
    const response = await this.httpClient.send({
      method: 'PATCH',
      path,
      token,
      data: content
    });
    return this.convertFromJson(response);
  }
  /**
   * Deletes a content item
   *
   * @param id ID of the content item
   */


  async delete(id) {
    const token = await this.authenticationManager.authenticate();
    const path = this.buildPath(id);
    await this.httpClient.send({
      method: 'DELETE',
      path,
      token
    });
    return true;
  }
  /**
   * Updates the status of a content item
   *
   * @param id ID of the content item
   * @param status the new status
   */


  async updateStatus(id, status) {
    const token = await this.authenticationManager.authenticate();
    const path = this.buildPath(id + '/status');
    const data = {
      Status: status.status
    };

    if (status.dueTime !== undefined) {
      data.DueTime = status.dueTime.toISOString();
    }

    const response = await this.httpClient.send({
      method: 'PUT',
      path,
      token,
      data
    });
    return this.convertFromJson(response);
  }
  /**
   * Discards changes to a content item
   *
   * @param id ID of the content item
   */


  async discard(id) {
    const token = await this.authenticationManager.authenticate();
    const path = this.buildPath(id + '/discard');
    const response = await this.httpClient.send({
      method: 'PUT',
      path,
      token
    });
    return this.convertFromJson(response);
  } // Converts dates etc.


  convertFromJson(json) {
    const res = Object.assign({}, json);
    res.created = new Date(json.created);
    res.lastModified = new Date(json.lastModified);
    return res;
  } // TODO: Extract to helper


  buildPath(suffix = '', params) {
    let path = `/api/content/${this.config.appName}/${this.schema}/${suffix}`;

    if (params !== undefined && params !== {}) {
      if (params instanceof _squidexQuery.SquidexJsonQuery) {
        params.q = JSON.stringify(params.q);
      }

      const qs = new URLSearchParams(params);
      path += '?' + qs;
    }

    return path;
  }

}

exports.ContentSchema = ContentSchema;
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../src/schemas/content.ts"],"names":["ContentSchema","constructor","config","httpClient","authenticationManager","query","draft","token","authenticate","path","buildPath","response","send","method","items","map","x","convertFromJson","querySingle","SquidexJsonQuery","$top","create","content","publish","data","update","id","patch","delete","updateStatus","status","Status","dueTime","undefined","DueTime","toISOString","discard","json","res","Object","assign","created","Date","lastModified","suffix","params","appName","schema","q","JSON","stringify","qs","URLSearchParams"],"mappings":"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","sourcesContent":["import { SquidexClientConfiguration } from '../configuration';\nimport { AuthenticationManager } from '../authentication/authentication-manager';\nimport { HttpClient } from '../http';\nimport { SquidexQuery, SquidexJsonQuery } from './squidex-query';\nimport { SquidexContent } from './squidex-content';\nimport { SquidexContentCollection } from './squidex-content-collection';\nimport { SquidexStatusUpdate } from './squidex-status-update';\n\nexport class ContentSchema {\n    public schema: string;\n\n    constructor(\n        private readonly config: SquidexClientConfiguration,\n        private readonly httpClient: HttpClient,\n        private readonly authenticationManager: AuthenticationManager,\n    ) {}\n\n    /**\n     * Returns all content from the API matching `query`\n     * Set `draft` to true to return content in draft\n     * */\n    public async query<T = any>(\n        query: SquidexQuery = {},\n        draft = false,\n    ): Promise<SquidexContentCollection<SquidexContent<T>>> {\n        const token = await this.authenticationManager.authenticate();\n        const path = this.buildPath('', query);\n\n        const response = await this.httpClient.send<T, SquidexContentCollection<SquidexContent<T>>>({\n            method: 'GET',\n            path,\n            token,\n            draft,\n        });\n\n        response.items = response.items.map(x => {\n            return this.convertFromJson<T>(x);\n        });\n\n        return response;\n    }\n\n    /**\n     * Returns the first content item from the API matching `query`\n     * Set `draft` to true to return content in draft\n     * */\n    public async querySingle<T = any>(query: SquidexQuery = {}, draft = false): Promise<SquidexContent<T>> {\n        if (!(query instanceof SquidexJsonQuery)) {\n            query.$top = 1;\n        }\n\n        const response = await this.query(query, draft);\n\n        return response.items[0];\n    }\n\n    /**\n     * Creates a new content item\n     *\n     * @param publish whether to publish the content item immediately\n     */\n    public async create<T = any, R = T>(content: T, publish = false): Promise<SquidexContent<R>> {\n        const token = await this.authenticationManager.authenticate();\n        const path = this.buildPath('', { publish });\n\n        const response = await this.httpClient.send<T, SquidexContent<R>>({\n            method: 'POST',\n            path,\n            token,\n            data: content,\n        });\n\n        return this.convertFromJson<R>(response);\n    }\n\n    /**\n     * Updates a content item\n     *\n     * @param id ID of the content item\n     */\n    public async update<T = any>(id: string, content: T): Promise<SquidexContent<T>> {\n        const token = await this.authenticationManager.authenticate();\n        const path = this.buildPath(id);\n\n        const response = await this.httpClient.send<T, SquidexContent<T>>({\n            method: 'PUT',\n            path,\n            token,\n            data: content,\n        });\n\n        return this.convertFromJson<T>(response);\n    }\n\n    /**\n     * Patches a content item\n     *\n     * @param id ID of the content item\n     */\n    public async patch<T = any>(id: string, content: Partial<T>): Promise<SquidexContent<T>> {\n        const token = await this.authenticationManager.authenticate();\n        const path = this.buildPath(id);\n\n        const response = await this.httpClient.send<T, SquidexContent<T>>({\n            method: 'PATCH',\n            path,\n            token,\n            data: content,\n        });\n\n        return this.convertFromJson<T>(response);\n    }\n\n    /**\n     * Deletes a content item\n     *\n     * @param id ID of the content item\n     */\n    public async delete<T = any>(id: string): Promise<boolean> {\n        const token = await this.authenticationManager.authenticate();\n        const path = this.buildPath(id);\n\n        await this.httpClient.send<T, boolean>({\n            method: 'DELETE',\n            path,\n            token,\n        });\n\n        return true;\n    }\n\n    /**\n     * Updates the status of a content item\n     *\n     * @param id ID of the content item\n     * @param status the new status\n     */\n    public async updateStatus<T = any>(id: string, status: SquidexStatusUpdate): Promise<SquidexContent<T>> {\n        const token = await this.authenticationManager.authenticate();\n        const path = this.buildPath(id + '/status');\n\n        const data: { [key: string]: string } = {\n            Status: status.status,\n        };\n\n        if (status.dueTime !== undefined) {\n            data.DueTime = status.dueTime.toISOString();\n        }\n\n        const response = await this.httpClient.send<T, SquidexContent<T>>({\n            method: 'PUT',\n            path,\n            token,\n            data,\n        });\n\n        return this.convertFromJson<T>(response);\n    }\n\n    /**\n     * Discards changes to a content item\n     *\n     * @param id ID of the content item\n     */\n    public async discard<T = any>(id: string): Promise<SquidexContent<T>> {\n        const token = await this.authenticationManager.authenticate();\n        const path = this.buildPath(id + '/discard');\n\n        const response = await this.httpClient.send<T, SquidexContent<T>>({\n            method: 'PUT',\n            path,\n            token,\n        });\n\n        return this.convertFromJson<T>(response);\n    }\n\n    // Converts dates etc.\n    private convertFromJson<T>(json: any): SquidexContent<T> {\n        const res = Object.assign({}, json);\n        res.created = new Date(json.created);\n        res.lastModified = new Date(json.lastModified);\n        return res;\n    }\n\n    // TODO: Extract to helper\n    private buildPath(suffix = '', params?: any): string {\n        let path = `/api/content/${this.config.appName}/${this.schema}/${suffix}`;\n\n        if (params !== undefined && params !== {}) {\n            if (params instanceof SquidexJsonQuery) {\n                params.q = JSON.stringify(params.q);\n            }\n            const qs = new URLSearchParams(params);\n            path += '?' + qs;\n        }\n\n        return path;\n    }\n}\n"]}