Prisma: Updates or creates do not run if response not required

[s7au]

Not game breaking but if there is a stand alone call to update database without the response being required the call does not get run.
e.g.

function test(ctx, email, name) {
  ctx.photon.users
      .update({
         where: {
            email,
          },
          data: {
            name
          },
      })
}

The above does not run the update.
However something like this will work:

function test(ctx, email, name) {
  ctx.photon.users
      .update({
         where: {
            email,
          },
          data: {
            name
          },
      })
    .catch(error => console.log(error))
}

I mean maybe an async function should never be called without some sort of processing of the response but I am not sure the above behaviour is intuitive. Using prisma2 2.0.0-preview015

[pantharshit00]

I can confirm this as a bug. Any calls that a photon user make should fire a promise even though the user necessarily have handled the promise.

Here is a reproduction for internal use: https://github.com/harshit-test-org/prisma-prisma2-868

[thomasio101]

I think I might have found the cause of this bug!

(Please note that I haven't created an exact reproduction of the issue, but I still have a strong suspicion that this is the cause of the bug.)

class UserClient {
    constructor(_dmmf, _fetcher, _queryType, _rootField, _clientMethod, _args, _path, _isList = false) {
        this._dmmf = _dmmf;
        this._fetcher = _fetcher;
        this._queryType = _queryType;
        this._rootField = _rootField;
        this._clientMethod = _clientMethod;
        this._args = _args;
        this._path = _path;
        this._isList = _isList;
        // @ts-ignore
        if (typeof window === 'undefined' && process.env.NODE_ENV !== 'production') {
            const error = new Error();
            if (error && error.stack) {
                const stack = error.stack;
                this._callsite = stack;
            }
        }
    }
    posts(args) {
        const prefix = this._path.includes('select') ? 'select' : this._path.includes('include') ? 'include' : 'select';
        const path = [...this._path, prefix, 'posts'];
        const newArgs = runtime_1.deepSet(this._args, path, args || true);
        this._isList = true;
        return new PostClient(this._dmmf, this._fetcher, this._queryType, this._rootField, this._clientMethod, newArgs, path, this._isList);
    }
    get _document() {
        const { _rootField: rootField } = this;
        const document = runtime_1.makeDocument({
            dmmf: this._dmmf,
            rootField,
            rootTypeName: this._queryType,
            select: this._args
        });
        try {
            document.validate(this._args, false, this._clientMethod);
        }
        catch (e) {
            const x = e;
            if (x.render) {
                if (this._callsite) {
                    e.message = x.render(this._callsite);
                }
            }
            throw e;
        }
        return runtime_1.transformDocument(document);
    }
    /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then(onfulfilled, onrejected) {
        if (!this._requestPromise) {
            this._requestPromise = this._fetcher.request(this._document, this._path, this._rootField, 'User', this._isList, this._callsite);
        }
        return this._requestPromise.then(onfulfilled, onrejected);
    }
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch(onrejected) {
        if (!this._requestPromise) {
            this._requestPromise = this._fetcher.request(this._document, this._path, this._rootField, 'User', this._isList, this._callsite);
        }
        return this._requestPromise.catch(onrejected);
    }
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally) {
        if (!this._requestPromise) {
            this._requestPromise = this._fetcher.request(this._document, this._path, this._rootField, 'User', this._isList, this._callsite);
        }
        return this._requestPromise.finally(onfinally);
    }
}

More specifically, take a look at the then, catch and finally methods:

     /**
     * Attaches callbacks for the resolution and/or rejection of the Promise.
     * @param onfulfilled The callback to execute when the Promise is resolved.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of which ever callback is executed.
     */
    then(onfulfilled, onrejected) {
        if (!this._requestPromise) {
            this._requestPromise = this._fetcher.request(this._document, this._path, this._rootField, 'User', this._isList, this._callsite);
        }
        return this._requestPromise.then(onfulfilled, onrejected);
    }
    /**
     * Attaches a callback for only the rejection of the Promise.
     * @param onrejected The callback to execute when the Promise is rejected.
     * @returns A Promise for the completion of the callback.
     */
    catch(onrejected) {
        if (!this._requestPromise) {
            this._requestPromise = this._fetcher.request(this._document, this._path, this._rootField, 'User', this._isList, this._callsite);
        }
        return this._requestPromise.catch(onrejected);
    }
    /**
     * Attaches a callback that is invoked when the Promise is settled (fulfilled or rejected). The
     * resolved value cannot be modified from the callback.
     * @param onfinally The callback to execute when the Promise is settled (fulfilled or rejected).
     * @returns A Promise for the completion of the callback.
     */
    finally(onfinally) {
        if (!this._requestPromise) {
            this._requestPromise = this._fetcher.request(this._document, this._path, this._rootField, 'User', this._isList, this._callsite);
        }
        return this._requestPromise.finally(onfinally);
    }

As you can see, this._fetcher.request is only called whenever a callback is attached to the client. This means that the database query is never executed until either then, catch or finally is called.

[timsuchanek]

Thanks for raising this issue.
This indeed is the first issue I declare as "Won't fix".

So first of all, you're right, that from the Promise spec perspective, Photons behavior is not adhering to the spec.

However, that's also neither necessary nor possible.

Consider this example:

  const post = await photon.posts.update({
    data: {},
    where: {
      id: 'id'
    }
  }).author()

If we would directly execute the update, as soon, as .update is being called - we can't have a .author() anymore, as the Promise is already fired.
Therefore, our API is not 100% a Promise API, but Promise-like.
So in your test function, you have to explicitly call one of the Promise methods that @thomasio101 mentioned (then, catch or finally).

This is the tradeoff we get from having this kind of fluent API, but after looking into the tradeoffs of the alternative approaches, we decided that this is the API we want to go with.

Any library with this chaining-style will have this problem. We had the same situation with https://github.com/prisma-archive/chromeless.