Every features needed to support push for mailboxes

To have a way to have direct discussions with the community

Currently the lib does nothing where errors are encountered.
The response type is incorrectly typed if it happens.

See https://jmap.io/spec-core.html#errors

A solution is to catch them and throw them to make the promise reject instead of resolve so the response type will be unchanged.

As a library user (eg: OpenPaas)
I want to get all the Mailbox changes using only one method
So that I do not have to worry about the hasMoreChanges mechanic which will be handled by the library

When I get all the changes
And the response property hasMoreChanges is false
Then the behaviour is the same than mailbox_changes

When I get all the changes
And the response property hasMoreChanges is true
Then more requests are made and merged until hasMoreChanges is false
And the client should get a response like if it was done in one request (but it will take more time)

Merging responses would be:

• union of created (minus those in destroyed) -> if a Mailbox was created and destroyed, no need to fetch it
• union of updated (minus those on created and those on destroyed) -> if a mailbox was created and updated, it will be fetched because in created; if a mailbox was updated and destroyed, no need to fetch it
• union of destroyed (minus those on created) -> if a Mailbox was created and destroyed, no need to remove it

The spec does not guarantee the personal(primary mail) account is the first element of session.accounts. I'm not sure whether JamesServer supports account/mailbox sharing. But cyrus-imapd seems that the personal account always is the last element of session.accounts.

I suggest that we add a getPersonalAccountId() method, and keep getFirstAccountId until 2.0 release.

Push documentation https://jmap.io/spec-core.html#push

We should be able to open a communication channel using websockets to receive StateChange notifications.
The library should take care of the authentication.

For an authentication and request example using ticket on James: https://github.com/linagora/tmail-backend/pull/78/files#diff-652928d50d74bf6233709ab2fb095e4909b554d8e6b3ede18785277964803795

• Get the ticket (using the url on the session)
• Use the ticket to open a websocket connection (query parameter)
• Filter to get only mailboxes ones (will probably need rxjs observables) this is about filtering them when different entities will be subscribed, we will need to be able to get one observable for each kind but only one websocket opened

Given a client with session fetched
When call the method to get push notifications
And there is an error getting the ticket (Authentication)
Then the returned observable throws an error

Given a client with session fetched
When call the method to get push notifications
And there is an error opening the websocket (with ticket)
Then the returned observable throws an error

Given a client with session fetched
When call the method to get Mailbox push notifications
And a Mailbox is added
Then the returned observable emits the StateChange for the Mailbox
TODO How do we know the observable is ready to receive StateChange when the Mailbox is added?

Given a client with session fetched
When call the method to get Mailbox push notifications
And an Email is added
Then the returned observable does not emit the StateChange for the Email
TODO How do we know the observable is ready to receive StateChange when the Mailbox is added?

Since this is purely frontend library and Jest should be responsible only for unit testing, not E2E testing, then I recommend using Travis CI, which is integrated in Github environment as far as I know.

Originally posted by @jeserkin in #17 (comment)

Right now it's not clear from the readme that passing a transport is required when initializing a client, nor is it clear how to use several of the transports exposed in utils

import { Client } from "jmap-client-ts";
import { FetchTransport } from "jmap-client-ts/lib/utils/fetch-transport";

let client = new Client({
  accessToken:
    "....",
  sessionUrl: "https://api.example.com/jmap/session",
  transport: new FetchTransport(fetch),
});

No tests sounds like a bad idea*:

I would suggest to use linagora/james-memorydocker image to start a JMAP server against which to test the cient...

To reduce code duplication and make it more readable.

See https://jmap.io/spec-mail.html#vacationresponseset

What is the impact of moving this repository?

• Build tools?
• External links?

See https://jmap.io/spec-mail.html#vacationresponseget

We may forget to remove .only or the leading f on tests, and if not seen it can compromise every tests running in the future.

We should not be able to commit/merge focused tests.

When a commit is tagged, continuous integration should build and push the release to npmjs.

I was looking through code and one thing that stuck in my eye more than anything else was, that http-request.ts was using pure XMLHttpRequest.

If the idea is to not add any new dependencies, then I'd suggest using https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API

But if dependencies are not the issue, then https://github.com/axios/axios is a good fit.

Implement the Mailbox/set of the Jmap RFC https://jmap.io/spec-mail.html#mailboxset
The method should be in the src/index.ts file, and named mailbox_set.
Data structures can be created if needed in src/types.ts.

Mainly issue is regarding -> https://jmap.io/spec-core.html#binary-data
In session response we have a bunch of different URLs including

{
  "downloadUrl": "http://localhost/download/{accountId}/{blobId}/?type={type}&name={name}",
  "uploadUrl": "http://localhost/upload/{accountId}"
}

So as far as I can tell, what can be done on jmap-client-ts level is:

• return URL with accountId replaced, since it is present in session response as well.
• For upload, there could be a type definition for response as mentioned here https://jmap.io/spec-core.html#uploading-binary-data
• Also for upload, there could be an entire method present, that would allow data upload. End-user should provide only body value, e.g. Blob

If there are any other suggestions on how to proceed with it, then I would love to hear about it.

Based on spec https://jmap.io/spec-mail.html#emailget, there should be more properties available. E.g. sentAt, hasAttachment. Did not look through all of them, maybe there are others, that are missing.

Was wondering, whether it wasn't noticed, when type was been created or spec on jmap.io is out of date?

https://github.com/linagora/jmap-client-ts/blob/main/src/types.ts#L235

Implement the Email/set of the Jmap RFC https://jmap.io/spec-mail.html#emailset
The method should be in the src/index.ts file, and named email.
Data structures can be created if needed in src/types.ts.

See https://jmap.io/spec-mail.html#mailboxchanges

https://jmap.io/spec-mail.html#emailchanges

Given

getEmailsWithSpecificProperties(emailIds: string[], properties: ?): Observable<IEmailGetResponse> {
    return from(this.fetchSession())
      .pipe(
        mergeMap(session => from(this.jmapClient.email_get({
          accountId: Object.keys(session.accounts)[0],
          ids: emailIds,
          fetchAllBodyValues: true,
          properties
        })))
      );
  }

What would properties type be, to accommodate provided method?

Based on the question, it seems to me, that properties?: (keyof Properties)[]; is not the desired way of specifying type.

Since I used this not up to date (it was written for Jmap draft) page https://jmap.io/server.html to make them (not entirely though), there might be some properties that do not exist, like the deleted property on IMailboxProperties.

Add a file to help people contribute to the project.

It may specify (but not limited to):

• how to test the project
• coding rules
• commit formatting
• how git should be used on the project
• how to use issues

The Angular CONTRIBUTING.md may help as example: https://github.com/angular/angular/blob/master/CONTRIBUTING.md

See https://jmap.io/spec-mail.html#emailsubmissionset

Problem:
When uploading Blob and then attaching to email with Email/set it provides attachment with new ID, that is related to email object. e.g. Email -> blobId: 'XXXXX', then attachment in that email will be e.g. partId: '5', blobId: 'XXXXX_5'.

When creating new email version (e.g. sender changed email subject), then it will not be created if I pass same list of attachments with it. I assume, that issue is that new version will have e.g. blobId: 'YYYYY' and it has no information about blobId: 'XXXXX'. Therefore it will not be able to get attachment, that has blobId: 'XXXXX_5'.

Expected behaviour:
Version 1 - it can find attachment by ID and copy it with new id, that will be linked to new Email version. (Version is based on the ability to copy attachment between accounts - https://jmap.io/spec-core.html#blobcopy)
Version 2 - it can provide original attachment id (the one, that is received in response of blob upload), so that it can be provided for new email version

NB!! Might be James and not JMAP related issue. Might be both.

[...] we should enforce fixed versions to prevent attacks via the build system...

Originally posted by @chibenwa in #62 (comment)

First, James 3.7.0 have implemented Thread/Get (JAMES-3516). It's an important feature and I'd like to push my patch that had been working well with cyrus-imapd.

Second, current constructor has an optional overriddenApiUrl argument. I thought we need it when the real James server serves behind a proxy with rewritten path/port (or our test container's port mapping ). But apiUrl wasn't the only URL in jmap session response. downloadUrl, uploadUrl, eventSourceUrl, ... all need to be replaced in this scenario. Should we use overriddenUrl-object instead of it?

It feels like a bug, but I am not sure.

So the use case is editing one draft multiple times. Since emails are immutable to a certain degree in James, the only way at the moment, that I was able to find is to create new email with Email/set -> create and remove previous version with Email/set -> destroy.

Now moving and focusing on attachments.
When uploading binary data successfully one does receive response in a form:

{
  "accountId":"5a20d72b9605345c1b526c6cba0565f699dfbde43f735d68c689dada5b3bfb85",
  "blobId":"lxcmnvkkfkudryrqttcj",
  "type":"text/css",
  "size":29
}

Adding this response with additional name property as attachment for Email/set -> create works fine, but attachments, that come back with Email/get have following structure:

{
  "charset": "us-ascii",
  "disposition": "attachment",
  "size": 8480,
  "partId": "5",
  "blobId": "0207d9f0-9757-11eb-a1b2-658a285e665b_5",
  "name": "Book1.xlsx",
  "type": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
}

Here blobId looks differently.

Now the issue itself is with doing Email/set -> create with attachments, where blobId is e.g. "0207d9f0-9757-11eb-a1b2-658a285e665b_5"
Response is negative invalidArguments ... Attachment not found: 0207d9f0-9757-11eb-a1b2-658a285e665b_5

So I guess the question is, whether it is James configuration issue or whether it is flawed logic on my part or something else?

I was looking through the code and found my old comment in Email/query. At the moment sorting is resolved through

comparator: [{
  property: 'receivedAt',
  isAscending: false
}]

even though there is no such property in any documentation (don't remember where it was found).

On the other hand first example on this page https://jmap.io/spec-mail.html#examples shows something different. It shows, that there should be sort property. It is present in documentation, but it is not working.

So the question is, is documentation correct regarding this or it needs to be updated to reflect the actual state?

Simple question but it would be really nice to use back-reference to chain JMAP calls and reduce server roundtrips.

(For someone like me based in Vietnam this is actually critical!)

You could:

start with a mailbox query to retrieve the guy INBOX
Then back-reference the INBOX in the email/query
And finally back-reference the ids in the Email/get

Doing all of that with a single network roundtrip, with a single API call.

Is there planned support for back-references in jmap-client-ts?

I would advise the maintainer to implement it early, in order to avoid generating technical debt.

See https://jmap.io/spec-core.html#references-to-previous-method-results

[[ "Foo/changes", {
    "accountId": "A1",
    "sinceState": "abcdef"
}, "t0" ],
[ "Foo/get", {
    "accountId": "A1",
    "#ids": {
        "resultOf": "t0",
        "name": "Foo/changes",
        "path": "/created"
    }
}, "t1" ]]

See https://jmap.io/spec-mail.html#emailsubmissionchanges

When I run tests, I don't want to use the overridden...Url parameter on jmap-client-ts, the only configurable URL for the client should be the session one, and other URLs are provided by the session.

Since the docker has a dynamic port, the URL is not know before the container is started.

It seems that those URLs are defined in jmap.properties file (see https://james.apache.org/server/config-jmap.html)

Does James support setting those URLs after is is started? With the file? With some commands?

If this is not possible, we can try to set up a proxy to redirect to James, setting proxy destination after it is started, but the proxy should have a constant URL?

Setup a linter to ensure a consistent code style.

I'm getting a 400 response but only getting a generic error message indicating the http response status, which makes it difficult to figure out what went wrong

Push documentation https://jmap.io/spec-core.html#push

See https://jmap.io/spec-mail.html#emailsubmissionget

Why?

To easily know which methods are low and high level.

How?

Separate files?

// Low level
client.lowLevel.mailbox_get(...);

// High level
client.getAllMailboxes(...);

About mailbox_changes

Issue #45
What about the case of mailbox_changes to get changes until hasMoreChanges is false?
Is it low level because its response is the same, and it just mimics the simple mailbox_changes using the same data structure?
Or is it high level because it does more than just making a simple JMAP request?

CURRENT

No referenced

TO DO

https://jmap.io/software.html

If you’re working on a project that uses JMAP, please [open an issue](https://github.com/jmapio/jmap/issues) or make a [pull request](https://github.com/jmapio/jmap/pulls) on GitHub to update this page.

Also reference jmap-client-ts lib to https://github.com/linagora/jmap-client