Support alternative REST api paths

Hi! Currently this tool supports hardcoded path /wiki/rest/api

Line 14 in 20a5505

protected urlSuffix = '/wiki/rest/';

It's possible to redefine in the inherited class , but that's not probably the most obvious thing .

How about exposing urlPrefix as a config parameter?

Thanks!

Convert Dash-Cased Parameters to CamelCase in `getLabelPages`

In the getLabelPages function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getLabelPages<T = Models.Pagination<Models.Page>>(
  parameters: Parameters.GetLabelPages,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/labels/${parameters.id}/pages`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getLabelPages<T = Models.Pagination<Models.Page>>(
  parameters: Parameters.GetLabelPages,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/labels/${parameters.id}/pages`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getInlineCommentChildren`

In the getInlineCommentChildren function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getInlineCommentChildren<T = Models.Pagination<Models.InlineCommentChildren>>(
  parameters: Parameters.GetInlineCommentChildren,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/inline-comments/${parameters.id}/children`,
    method: 'GET',
    params: {
      'serialize-ids-as-strings': true,
      'body-format': parameters['body-format'],
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getInlineCommentChildren<T = Models.Pagination<Models.InlineCommentChildren>>(
  parameters: Parameters.GetInlineCommentChildren,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/inline-comments/${parameters.id}/children`,
    method: 'GET',
    params: {
      'serialize-ids-as-strings': true,
      'body-format': parameters.bodyFormat,
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
    },
  };

  return this.client.sendRequest(config, callback);
}

Thanks

Hey,

Thanks for your work on this package. It was a big help with my plugin (https://obsidian-confluence.com/). Thanks for being happy to take contributions and work with me on the features I needed.

Called you out at the top of https://obsidian-confluence.com/thanks.html 😄

Cheers,
Andrew

Enhancement: add `data` property to `blogPost.createBlogPost`

This issue tracks the need to enhance the blogPost.createBlogPost method by including a data property. The data property should have the following structure:

data: {
  spaceId: parameters.spaceId, // Required field of type string
  status: parameters.status, // Type: string
  title: parameters.title, // Type: string
  body: parameters.body, // Type: One of [BlogPostBodyWrite, BlogPostNestedBodyWrite]
}

PR should include also typings for spaceId, status, title, body

Reference:

For more context and detailed information, please refer to the Confluence REST API documentation.

Confluence V2 API

There is a new V2 API for Confluence that has been released. https://community.developer.atlassian.com/t/release-of-new-endpoints-for-confluence-rest-api-v2/65242

Do you have a pattern you would like to follow to put these into the library?

Convert Dash-Cased Parameters to CamelCase in `getPageById`

In the getPageById function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getPageById<T = Models.Page>(parameters: Parameters.GetPageById, callback?: Callback<T>): Promise<void | T> {
  const config: RequestConfig = {
    url: `/pages/${parameters.id}`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      'get-draft': parameters['get-draft'],
      version: parameters.version,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getPageById<T = Models.Page>(parameters: Parameters.GetPageById, callback?: Callback<T>): Promise<void | T> {
  const config: RequestConfig = {
    url: `/pages/${parameters.id}`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      'get-draft': parameters.getDraft,
      version: parameters.version,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Attachments download

I tried to use the downloadAttachement feature, but the encoding seems incorrect:

�PNG... --> should begin with <89>PNG...

Any ideas?

Enhancement: add `data` property to `blogPost.updateBlogPost`

This issue tracks the need to enhance the blogPost.updateBlogPost method by including a data property. The data property should have the following structure:

data: {
  id: parameters.updateId, // Required field of type string
  status: parameters.status, // Required field of type: string
  title: parameters.title, // Required field of type: string
  body: parameters.body, // Required field of type: One of [BlogPostBodyWrite, BlogPostNestedBodyWrite]
  version: parameters.version, // Required field of type Version
}

PR should include also typings for updateId, status, title, body, version

Reference:

For more context and detailed information, please refer to the Confluence REST API documentation.

Adding attachments complains about mediatype

Hi,

I am getting 415 when trying to add attachments using the method bellow. Do you have any unit tests or examples on how this should be used?

confluence.js/src/api/contentAttachments.ts

Line 82 in 738dc56

async createAttachments<T = Models.ContentArray>(

Convert Dash-Cased Parameters to CamelCase in `getTaskById`

In the getTaskById function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getTaskById<T = Models.Task>(parameters: Parameters.GetTaskById, callback?: Callback<T>): Promise<void | T> {
  const config: RequestConfig = {
    url: `/tasks/${parameters.id}`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getTaskById<T = Models.Task>(parameters: Parameters.GetTaskById, callback?: Callback<T>): Promise<void | T> {
  const config: RequestConfig = {
    url: `/tasks/${parameters.id}`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Cannot get spaces, spaceKey values issue

Hi there, trying to get multiple spaces from Confluence however it seems there is an issue.

Here is the code that I use to get my spaces:

await client.space.getSpaces({ spaceKey: ['KEY1', 'KEY2'] })

The documentation said:

Returns information about a number of spaces.
Example request URI(s):
http://example.com/rest/api/space?spaceKey=TST&spaceKey=ds

However the generated URL is: https://example.atlassian.net/wiki/rest/api/space?spaceKey=KEY1,KEY2
Instead of: https://example.atlassian.net/wiki/rest/api/space?spaceKey=KEY1&spaceKey=KEY2

Convert Dash-Cased Parameters to CamelCase in `getCustomContentByTypeInBlogPost`

In the getCustomContentByTypeInBlogPost function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getCustomContentByTypeInBlogPost<T = Models.Pagination<Models.CustomContent>>(
  parameters: Parameters.GetCustomContentByTypeInBlogPost,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/blogposts/${parameters.id}/custom-content`,
    method: 'GET',
    params: {
      type: parameters.type,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'body-format': parameters['body-format'],
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getCustomContentByTypeInBlogPost<T = Models.Pagination<Models.CustomContent>>(
  parameters: Parameters.GetCustomContentByTypeInBlogPost,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/blogposts/${parameters.id}/custom-content`,
    method: 'GET',
    params: {
      type: parameters.type,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'body-format': parameters.bodyFormat,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

ConvertContentBody don't use expand parameter data

Hi, I'm using ConvertContentBody api with expand parameter but the request hasn't it.

Bug:

Parameters.ConvertContentBody has expand?: string[]; but the code never use it.

Solution:

Please, add expand as a string with comma separators to params object at this line https://github.com/MrRefactoring/confluence.js/blob/master/src/api/contentBody.ts#L53

Regards

Convert Dash-Cased Parameters to CamelCase in `getCustomContentById`

In the getCustomContentById function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getCustomContentById<T = Models.CustomContent>(
  parameters: Parameters.GetCustomContentById,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/custom-content/${parameters.id}`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      version: parameters.version,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getCustomContentById<T = Models.CustomContent>(
  parameters: Parameters.GetCustomContentById,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/custom-content/${parameters.id}`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      version: parameters.version,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getCustomContentVersions`

In the getCustomContentVersions function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getCustomContentVersions<T = Models.Pagination<Models.CustomContentVersion>>(
  parameters: Parameters.GetCustomContentVersions,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/custom-content/${parameters.customContentId}/versions`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      cursor: parameters.cursor,
      limit: parameters.limit,
      sort: parameters.sort,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getCustomContentVersions<T = Models.Pagination<Models.CustomContentVersion>>(
  parameters: Parameters.GetCustomContentVersions,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/custom-content/${parameters.customContentId}/versions`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      cursor: parameters.cursor,
      limit: parameters.limit,
      sort: parameters.sort,
    },
  };

  return this.client.sendRequest(config, callback);
}

Set `serializeIdsAsStrings` to true for all of endpoint use this.

What we have

A lot of endpoints added serializeIdsAsStrings property. Example

What should be done

For all endpoints serializeIdsAsStrings setted to true by default
serializeIdsAsStrings removed from all Models and Parameters

Example what I want to see

Was

    const config: RequestConfig = {
      url: `/attachments/${parameters.id}`,
      method: 'GET',
      params: {
        version: parameters.version,
        'serialize-ids-as-strings': parameters.serializeIdsAsStrings,
      },
    };

Now

    const config: RequestConfig = {
      url: `/attachments/${parameters.id}`,
      method: 'GET',
      params: {
        version: parameters.version,
        'serialize-ids-as-strings': true,
      },
    };

Convert Dash-Cased Parameters to CamelCase in `getSpaceById`

In the getSpaceById function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getSpaceById<T = Models.Space>(parameters: Parameters.GetSpaceById, callback?: Callback<T>): Promise<void | T> {
  const config: RequestConfig = {
    url: `/spaces/${parameters.id}`,
    method: 'GET',
    params: {
      'description-format': parameters['description-format'],
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getSpaceById<T = Models.Space>(parameters: Parameters.GetSpaceById, callback?: Callback<T>): Promise<void | T> {
  const config: RequestConfig = {
    url: `/spaces/${parameters.id}`,
    method: 'GET',
    params: {
      'description-format': parameters.descriptionFormat,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getInlineCommentById`

In the getInlineCommentById function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getInlineCommentById<T = Models.InlineCommentModel>(
  parameters: Parameters.GetInlineCommentById,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/inline-comments/${parameters.commentId}`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      version: parameters.version,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getInlineCommentById<T = Models.InlineCommentModel>(
  parameters: Parameters.GetInlineCommentById,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/inline-comments/${parameters.commentId}`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      version: parameters.version,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getBlogPostById`

In the getBlogPostById function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getBlogPostById<T = Models.BlogPost>(
    parameters: Parameters.GetBlogPostById,
    callback?: Callback<T>,
): Promise<void | T> {
    const config: RequestConfig = {
      url: `/blogposts/${parameters.id}`,
      method: 'GET',
      params: {
        'body-format': parameters['body-format'],
        'get-draft': parameters['get-draft'],
        version: parameters.version,
        'serialize-ids-as-strings': true,
      },
    };

    return this.client.sendRequest(config, callback);
}

Expected function look:

async getBlogPostById<T = Models.BlogPost>(
    parameters: Parameters.GetBlogPostById,
    callback?: Callback<T>,
): Promise<void | T> {
    const config: RequestConfig = {
      url: `/blogposts/${parameters.id}`,
      method: 'GET',
      params: {
        'body-format': parameters.bodyFormat,
        'get-draft': parameters.getDraft,
        version: parameters.version,
        'serialize-ids-as-strings': true,
      },
    };

    return this.client.sendRequest(config, callback);
}

Write integration tests like we already have in the project.

Wrap `results`, `_links` to wapper.

[ServerClient] Creating and Updating attachments returns 415

Hello!

First of all thanks for this awesome lib! kudos to you 🥳

I think this is related to #23 , according to the [server documentation][https://docs.atlassian.com/ConfluenceServer/rest/7.18.3/#content/{id}/child/attachment-updateData] in order to update an attachment data the content-type header of the request needs to be multipart/form-data but it's currently being set to application/json

Please let me know if you need code examples and files, I can provide those, I'm reading a bit the code, trying to understand things, I will also try to submit a fix for this later🤞

Best regards
Gonzalo G

Convert Dash-Cased Parameters to CamelCase in `getBlogPostVersions`

In the getBlogPostVersions function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getBlogPostVersions<T = Models.Pagination<Models.BlogPostVersion>>(
  parameters: Parameters.GetBlogPostVersions,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/blogposts/${parameters.id}/versions`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      cursor: parameters.cursor,
      limit: parameters.limit,
      sort: parameters.sort,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getBlogPostVersions<T = Models.Pagination<Models.BlogPostVersion>>(
  parameters: Parameters.GetBlogPostVersions,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/blogposts/${parameters.id}/versions`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      cursor: parameters.cursor,
      limit: parameters.limit,
      sort: parameters.sort,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getPageFooterComments`

In the getPageFooterComments function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getPageFooterComments<T = Models.Pagination<Models.PageComment>>(
  parameters: Parameters.GetPageFooterComments,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/pages/${parameters.id}/footer-comments`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getPageFooterComments<T = Models.Pagination<Models.PageComment>>(
  parameters: Parameters.GetPageFooterComments,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/pages/${parameters.id}/footer-comments`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Cannot get body from `getContentById`

Trying to get the content body of a page when requesting it by ID:
await client.content.getContentById({ id: '1234', expand: 'body.view' })

However, the body field is not returned

When I do the call https://example.atlassian.net/wiki/rest/api/content/1234?expand=body.view, body field is present.
Interface Server/Parameters.GetContentById describe field expand?: string
But Api/Parameters.GetContentById describe field expand?: string[]
Signature seems to be more await client.content.getContentById({ id: '1234', expand: ['body'] }) } otherwise IDE with trigger a warning

Tried with string and string[] for expand parameter and with body and body.view but field body is still undefined.

Convert Dash-Cased Parameters to CamelCase in `getCustomContentByTypeInPage`

In the getCustomContentByTypeInPage function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getCustomContentByTypeInPage<T = Models.Pagination<Models.CustomContent>>(
  parameters: Parameters.GetCustomContentByTypeInPage,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/pages/${parameters.id}/custom-content`,
    method: 'GET',
    params: {
      type: parameters.type,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'body-format': parameters['body-format'],
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getCustomContentByTypeInPage<T = Models.Pagination<Models.CustomContent>>(
  parameters: Parameters.GetCustomContentByTypeInPage,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/pages/${parameters.id}/custom-content`,
    method: 'GET',
    params: {
      type: parameters.type,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'body-format': parameters.bodyFormat,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert query parameters to camelCase for `GET /tasks` endpoint

The GET /tasks endpoint in confluence.js library currently supports several query parameters as described in the Confluence OpenAPI documentation. However, these parameters are currently in a dash-case format, which is not consistent with the camelCase convention commonly used in JavaScript.

The task at hand is to convert all of these parameter names to camelCase format. Here are the parameters that need to be renamed:

body-format should be bodyFormat
include-blank-tasks should be includeBlankTasks
task-id should be taskId
space-id should be spaceId
page-id should be pageId
blogpost-id should be blogpostId
created-by should be createdBy
assigned-to should be assignedTo
completed-by should be completedBy
created-at-from should be createdAtFrom
created-at-to should be createdAtTo
due-at-from should be dueAtFrom
due-at-to should be dueAtTo
completed-at-from should be completedAtFrom
completed-at-to should be completedAtTo

By converting these parameter names to camelCase, we will ensure that our library adheres to the common naming conventions of JavaScript, making it more intuitive and easier to use for developers.

Please make sure that this change does not break any existing functionality, and update all relevant function calls and documentations accordingly.

metadata is not available for content creation

Hi!

I noticed that current content payload doesn't fully attract schema described here: https://docs.atlassian.com/ConfluenceServer/rest/8.3.1/#api/content-createContent

For example metadata is missing

Convert Dash-Cased Parameters to CamelCase in `getPageInlineComments`

In the getPageInlineComments function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getPageInlineComments<T = Models.Pagination<Models.PageInlineComment>>(
  parameters: Parameters.GetPageInlineComments,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/pages/${parameters.id}/inline-comments`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getPageInlineComments<T = Models.Pagination<Models.PageInlineComment>>(
  parameters: Parameters.GetPageInlineComments,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/pages/${parameters.id}/inline-comments`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getFooterCommentVersions`

In the getFooterCommentVersions function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getFooterCommentVersions<T = Models.Pagination<Models.CommentVersion>>(
  parameters: Parameters.GetFooterCommentVersions,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/footer-comments/${parameters.id}/versions`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      cursor: parameters.cursor,
      limit: parameters.limit,
      sort: parameters.sort,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getFooterCommentVersions<T = Models.Pagination<Models.CommentVersion>>(
  parameters: Parameters.GetFooterCommentVersions,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/footer-comments/${parameters.id}/versions`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      cursor: parameters.cursor,
      limit: parameters.limit,
      sort: parameters.sort,
    },
  };

  return this.client.sendRequest(config, callback);
}

Update content - missing required request body parameters

Hi again

updateContent is missing required body parameters - it is currently only sending 'body'

According to the docs it requires:

version
title
type

Convert Dash-Cased Parameters to CamelCase in `getSpaces`

In the getSpaces function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getSpaces<T = Models.Pagination<Models.Space>>(
  parameters?: Parameters.GetSpaces,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: '/spaces',
    method: 'GET',
    params: {
      ids: parameters?.ids,
      keys: parameters?.keys,
      type: parameters?.type,
      status: parameters?.status,
      labels: parameters?.labels,
      sort: parameters?.sort,
      'description-format': parameters?.['description-format'],
      cursor: parameters?.cursor,
      limit: parameters?.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getSpaces<T = Models.Pagination<Models.Space>>(
  parameters?: Parameters.GetSpaces,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: '/spaces',
    method: 'GET',
    params: {
      ids: parameters?.ids,
      keys: parameters?.keys,
      type: parameters?.type,
      status: parameters?.status,
      labels: parameters?.labels,
      sort: parameters?.sort,
      'description-format': parameters?.descriptionFormat,
      cursor: parameters?.cursor,
      limit: parameters?.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getPagesInSpace`

In the getPagesInSpace function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getPagesInSpace<T = Models.Pagination<Models.Page>>(
  parameters: Parameters.GetPagesInSpace,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/spaces/${parameters.id}/pages`,
    method: 'GET',
    params: {
      status: parameters.status,
      'body-format': parameters['body-format'],
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getPagesInSpace<T = Models.Pagination<Models.Page>>(
  parameters: Parameters.GetPagesInSpace,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/spaces/${parameters.id}/pages`,
    method: 'GET',
    params: {
      status: parameters.status,
      'body-format': parameters.bodyFormat,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Adjustment of all code instances where `sort?: {};` was incorrectly defined

#56

Create `next()` function for all paginate endpoints.

Convert Dash-Cased Parameters to CamelCase in `getCustomContentByTypeInSpace`

In the getCustomContentByTypeInSpace function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getCustomContentByTypeInSpace<T = Models.Pagination<Models.CustomContent>>(
  parameters: Parameters.GetCustomContentByTypeInSpace,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/spaces/${parameters.id}/custom-content`,
    method: 'GET',
    params: {
      type: parameters.type,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'body-format': parameters['body-format'],
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getCustomContentByTypeInSpace<T = Models.Pagination<Models.CustomContent>>(
  parameters: Parameters.GetCustomContentByTypeInSpace,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/spaces/${parameters.id}/custom-content`,
    method: 'GET',
    params: {
      type: parameters.type,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'body-format': parameters.bodyFormat,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

how to get an article on my wiki with this js

I'm a novice. I want to get an article on my wiki. What should I do

Convert Dash-Cased Parameters to CamelCase in `getPageVersions`

In the getPageVersions function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getPageVersions<T = Models.Pagination<Models.PageVersion>>(
  parameters: Parameters.GetPageVersions,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/pages/${parameters.id}/versions`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      cursor: parameters.cursor,
      limit: parameters.limit,
      sort: parameters.sort,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getPageVersions<T = Models.Pagination<Models.PageVersion>>(
  parameters: Parameters.GetPageVersions,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/pages/${parameters.id}/versions`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      cursor: parameters.cursor,
      limit: parameters.limit,
      sort: parameters.sort,
    },
  };

  return this.client.sendRequest(config, callback);
}

'urlSuffix' is better to be a configuration option.

Description

I think someone's Conluence home page is not start with /wiki/. Thanks!

Code

confluence.js/src/clients/baseClient.ts

Line 14 in ac097f5

protected urlSuffix = '/wiki/rest/';

Convert Dash-Cased Parameters to CamelCase in `getInlineCommentVersions`

In the getInlineCommentVersions function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getInlineCommentVersions<T = Models.Pagination<Models.CommentVersion>>(
  parameters: Parameters.GetInlineCommentVersions,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/inline-comments/${parameters.id}/versions`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      cursor: parameters.cursor,
      limit: parameters.limit,
      sort: parameters.sort,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getInlineCommentVersions<T = Models.Pagination<Models.CommentVersion>>(
  parameters: Parameters.GetInlineCommentVersions,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/inline-comments/${parameters.id}/versions`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      cursor: parameters.cursor,
      limit: parameters.limit,
      sort: parameters.sort,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getPages`

In the getPages function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getPages<T = Models.Pagination<Models.Page>>(
  parameters?: Parameters.GetPages,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: '/pages',
    method: 'GET',
    params: {
      id: parameters?.id,
      status: parameters?.status,
      'body-format': parameters?.['body-format'],
      cursor: parameters?.cursor,
      limit: parameters?.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getPages<T = Models.Pagination<Models.Page>>(
  parameters?: Parameters.GetPages,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: '/pages',
    method: 'GET',
    params: {
      id: parameters?.id,
      status: parameters?.status,
      'body-format': parameters?.bodyFormat,
      cursor: parameters?.cursor,
      limit: parameters?.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getBlogPostInlineComments`

In the getBlogPostInlineComments function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getBlogPostInlineComments<T = Models.Pagination<Models.BlogPostInlineComment>>(
  parameters: Parameters.GetBlogPostInlineComments,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/blogposts/${parameters.id}/inline-comments`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getBlogPostInlineComments<T = Models.Pagination<Models.BlogPostInlineComment>>(
  parameters: Parameters.GetBlogPostInlineComments,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/blogposts/${parameters.id}/inline-comments`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getTasks`

In the getTasks function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getTasks<T = Models.Pagination<Models.Task>>(
  parameters?: Parameters.GetTasks,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: '/tasks',
    method: 'GET',
    params: {
      'body-format': parameters?.['body-format'],
      'include-blank-tasks': parameters?.['include-blank-tasks'],
      status: parameters?.status,
      'task-id': parameters?.taskId,
      'space-id': parameters?.spaceId,
      'page-id': parameters?.pageId,
      'blogpost-id': parameters?.['blogpost-id'],
      'created-by': parameters?.['created-by'],
      'assigned-to': parameters?.['assigned-to'],
      'completed-by': parameters?.['completed-by'],
      'created-at-from': parameters?.['created-at-from'],
      'created-at-to': parameters?.['created-at-to'],
      'due-at-from': parameters?.['due-at-from'],
      'due-at-to': parameters?.['due-at-to'],
      'completed-at-from': parameters?.['completed-at-from'],
      'completed-at-to': parameters?.['completed-at-to'],
      cursor: parameters?.cursor,
      limit: parameters?.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getTasks<T = Models.Pagination<Models.Task>>(
  parameters?: Parameters.GetTasks,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: '/tasks',
    method: 'GET',
    params: {
      'body-format': parameters?.bodyFormat,
      'include-blank-tasks': parameters?.includeBlankTasks,
      status: parameters?.status,
      'task-id': parameters?.taskId,
      'space-id': parameters?.spaceId,
      'page-id': parameters?.pageId,
      'blogpost-id': parameters?.blogpostId,
      'created-by': parameters?.createdBy,
      'assigned-to': parameters?.assignedTo,
      'completed-by': parameters?.completedBy,
      'created-at-from': parameters?.createdAtFrom,
      'created-at-to': parameters?.createdAtTo,
      'due-at-from': parameters?.dueAtFrom,
      'due-at-to': parameters?.dueAtTo,
      'completed-at-from': parameters?.completedAtFrom,
      'completed-at-to': parameters?.completedAtTo,
      cursor: parameters?.cursor,
      limit: parameters?.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getCustomContentByType`

In the getCustomContentByType function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getCustomContentByType<T = Models.Pagination<Models.CustomContent>>(
  parameters: Parameters.GetCustomContentByType,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: '/custom-content',
    method: 'GET',
    params: {
      type: parameters.type,
      id: parameters.id,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'body-format': parameters['body-format'],
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getCustomContentByType<T = Models.Pagination<Models.CustomContent>>(
  parameters: Parameters.GetCustomContentByType,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: '/custom-content',
    method: 'GET',
    params: {
      type: parameters.type,
      id: parameters.id,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'body-format': parameters.bodyFormat,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getBlogPostFooterComments`

In the getBlogPostFooterComments function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getBlogPostFooterComments<T = Models.Pagination<Models.BlogPostComment>>(
  parameters: Parameters.GetBlogPostFooterComments,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/blogposts/${parameters.id}/footer-comments`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getBlogPostFooterComments<T = Models.Pagination<Models.BlogPostComment>>(
  parameters: Parameters.GetBlogPostFooterComments,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/blogposts/${parameters.id}/footer-comments`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Version 2 API Release checklist

Branch we are working

#40

All PR should have a target for this branch.

General

Api

Models

Paramerters

#57

Special thanks

I would like to extend my gratitude to the following individuals for their contributions and support:

Fabio Rodriguez made significant contributions to the Version 2 API Client of the confluence.js project. Here are the specific contributions:
#60
#61
#62
#63
#64
#65
#66
#67
#68
#69
#70
#71
#72
#73
#74
#75
#76
#77
#78
#79
#80
#81
#84

Augustus Thomas for his contribution to making Version 2 API Client.
#58
Haider Zaidi for his contribution to making Version 2 API Client.
#83
mukultotla for his contribution to making Version 2 API Client.
#82
Kunal Virk for his contribution to making Version 2 API Client.
#59

Convert Dash-Cased Parameters to CamelCase in `getFooterCommentById`

In the getFooterCommentById function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getFooterCommentById<T = Models.FooterCommentModel>(
  parameters: Parameters.GetFooterCommentById,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/footer-comments/${parameters.commentId}`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      version: parameters.version,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getFooterCommentById<T = Models.FooterCommentModel>(
  parameters: Parameters.GetFooterCommentById,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/footer-comments/${parameters.commentId}`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      version: parameters.version,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Convert Dash-Cased Parameters to CamelCase in `getFooterCommentChildren`

In the getFooterCommentChildren function, parameters with a dash (-) are used. The proposal is to replace these dash-cased parameters with camelCase.

The function currently looks like this:

async getFooterCommentChildren<T = Models.Pagination<Models.ChildrenComment>>(
  parameters: Parameters.GetFooterCommentChildren,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/footer-comments/${parameters.id}/children`,
    method: 'GET',
    params: {
      'body-format': parameters['body-format'],
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

Expected function look:

async getFooterCommentChildren<T = Models.Pagination<Models.ChildrenComment>>(
  parameters: Parameters.GetFooterCommentChildren,
  callback?: Callback<T>,
): Promise<void | T> {
  const config: RequestConfig = {
    url: `/footer-comments/${parameters.id}/children`,
    method: 'GET',
    params: {
      'body-format': parameters.bodyFormat,
      sort: parameters.sort,
      cursor: parameters.cursor,
      limit: parameters.limit,
      'serialize-ids-as-strings': true,
    },
  };

  return this.client.sendRequest(config, callback);
}

mrrefactoring / confluence.js Goto Github PK

confluence.js's People

Contributors

Stargazers

Watchers

Forkers

confluence.js's Issues

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

Reference:

The function currently looks like this:

Expected function look:

Reference:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

Bug:

Solution:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

What we have

What should be done

Example what I want to see

Was

Now

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

Description

Code

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

Branch we are working

General

Api

Models

Paramerters

Special thanks

The function currently looks like this:

Expected function look:

The function currently looks like this:

Expected function look:

Recommend Projects

Recommend Topics