ES6 Dirigible modules API

[vmutafov]

Currently, the Dirigible JS APIs are available only by require-ing them. With the support of ES6 modules (coming from GraalVM) we should choose a path convention for importing Dirigible modules. Let's look at the base64 package. As of now, it could be imported like:

const base64 = require("utils/v4/base64");

With the ES6 modules support, at first glance, it could be something like:

import base64 from "utils/v4/base64";

or

import { base64 } from "utils/v4";

Those two ways of importing look relatively nice but there is a possible issue with the from paths. The problem is that if we want to enable at a later point the GraalVM's own require function, in order not to support our own one, those paths would be treated like an npm package name as they are neither absolute nor relative paths. By specification, all npm package names should not have URL unfriendly names. In our case, the / would not be supported and GraalVM would throw an exception. So, we could change the paths to something like:

import base64 from "utils-v4-base64";

or

import { base64 } from "utils-v4";

But by doing that, those paths start to become a little bit verbose, especially the first one. Another issue for all these approaches is that it's also a bit hard for new users to understand from where are those packages coming from actually. We could solve these issues with a scoped name and a more modular way of importing:

import { base64 } from "@dirigible/utils-v4";

Having this, it's still a bit verbose if we must append the version at the end. It would maybe be better in terms of readability to have the imported module at the end of the from path:

import { base64 } from "@dirigible-v4/utils";

In this way, in my opinion, it would be a bit more readable and enables the users to easily change the used version when at some point in time we release a v5.
Although to have an explicit version stated by the user, we could still support the current way of importing the latest module version by having something like:

import { base64 } from "@dirigible/utils";

I believe the best way of enabling users to import Dirigible modules is by supporting the last two examples. In terms of implementation, they seem to be relatively simple to support and don't have any major shortcomings.

[ThuF]

Hi Vladimir,

I think the last two examples are the ones that we should select. They are easier to understand and follow. We should stick to the one without version (@dirigible/…) in our source code and samples and support @dirigible-v4/…, @dirigible-v5/… for versioning reasons.

Also could you estimate how much of an effort would be to swap our require(…) implementation with the one coming from GraalJS?

Regards,
Yordan