Problem with custom import function

[JerrySievert]

My goal is to have a custom import function, such as:

const { bar } = await my_import('foo.mjs');

or

const { bar } = my_import('foo.mjs');

from looking at code, it should be fairly straightforward:

• read the module from somewhere
• eval it as a module
• get its pointer
• get the module namespace
• return the module namespace

but, when I do this, I get an illegal access in js_build_module_ns().

here's a quick, dumbed down repo of the inner workings:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "quickjs.h"

const char *module = "const bar = (foo) => { console.log(`foo = ${foo}`); }; export { bar };";

const char *read_module(size_t *buf_len, const char *module_name) {
  if (strcmp(module_name, "bar.mjs") == 0) {
    *buf_len = strlen(module);
    return module;
  }

  return NULL;
}

JSValue module_load(JSContext *ctx, const char *module_name) {
  size_t buf_len;
  const char *buf;

  buf = read_module(&buf_len, module_name);
  if (!buf) {
    fprintf(stderr, "could not load module '%s'", module_name);

    JS_ThrowReferenceError(ctx, "could not load module '%s'", module_name);

    return JS_EXCEPTION;
  }

  fprintf(stderr, "Read module '%s': %s (%ld)", module_name, buf, buf_len);

  /* compile the module */
  JSValue res = JS_Eval(ctx, buf, buf_len, module_name,
                        JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);

  if (JS_IsException(res)) {
    const char *err = JS_ToCString(ctx, res);
    fprintf(stderr, "could not compile module '%s': %s", module_name, err);
    return JS_EXCEPTION;
  }

  JSModuleDef *module = (JSModuleDef *)JS_VALUE_GET_PTR(res);
  JSValue ns = JS_GetModuleNamespace(ctx, module);
  return ns;
}

int main() {
  JSRuntime *rt = JS_NewRuntime();
  JSContext *ctx = JS_NewContext(rt);

  JSValue ns = module_load(ctx, "bar.mjs");

  JS_FreeValue(ctx, ns);

  JS_FreeContext(ctx);
  JS_FreeRuntime(rt);

  return 0;
}

and my invalid access occurs here:

    frame #0: 0x000000010003a280 repro`js_build_module_ns(ctx=0x000000013f804470, m=0x000000013f8078c0) at quickjs.c:28712:42
   28709	                                  JS_PROP_VARREF);
   28710	                if (!pr)
   28711	                    goto fail;
-> 28712	                var_ref->header.ref_count++;
   28713	                pr->u.var_ref = var_ref;
   28714	            }
   28715	            break;

any help or pointers would be very much appreciated.

thanks!

[saghul]

When you use compile only you need to run the result afterwards with JS_EvalFunction.

[JerrySievert]

hm, either I'm not understanding you fully (I could be being very dense), or there's still something amiss:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include "quickjs.h"

const char *module = "print('in module'); const bar = (foo) => { print(`foo = ${foo}`); }; export { bar };";

static JSValue print(JSContext *ctx, JSValueConst this_val, int argc,
                         JSValueConst *argv) {
  if (argc) {
    for (int i = 0; i < argc; i++) {
      JSValue str = JS_ToString(ctx, argv[i]);
      const char *cstr = JS_ToCString(ctx, str);

      fprintf(stdout, "%s ", cstr);

      JS_FreeCString(ctx, cstr);
      JS_FreeValue(ctx, str);
    }

    fprintf(stdout, "\n");
  }

  return JS_UNDEFINED;
}

const char *read_module(size_t *buf_len, const char *module_name) {
  if (strcmp(module_name, "bar.mjs") == 0) {
    *buf_len = strlen(module);
    return module;
  }

  return NULL;
}

JSValue module_load(JSContext *ctx, const char *module_name) {
  size_t buf_len;
  const char *buf;

  buf = read_module(&buf_len, module_name);
  if (!buf) {
    fprintf(stderr, "could not load module '%s'", module_name);

    JS_ThrowReferenceError(ctx, "could not load module '%s'", module_name);

    return JS_EXCEPTION;
  }

  fprintf(stderr, "Read module '%s': %s (%ld)\n", module_name, buf, buf_len);

  /* compile the module */
  JSValue res = JS_Eval(ctx, buf, buf_len, module_name,
                        JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);

  if (JS_IsException(res)) {
    JSValue ex = JS_GetException(ctx);
    const char *err = JS_ToCString(ctx, ex);
    fprintf(stderr, "could not compile module '%s': %s", module_name, err);
    return JS_EXCEPTION;
  }

  JSValue res2 = JS_EvalFunction(ctx, res);

  if (JS_IsException(res2)) {
    const char *err = JS_ToCString(ctx, res2);
    fprintf(stderr, "could not evaluate module '%s': %s", module_name, err);
    return JS_EXCEPTION;
  }

  JSModuleDef *module = (JSModuleDef *)JS_VALUE_GET_PTR(res2);
  JSValue ns = JS_GetModuleNamespace(ctx, module);
  return ns;
}

static JSValue my_import(JSContext *ctx, JSValueConst this_val, int argc,
                         JSValueConst *argv) {
  const char *path = JS_ToCString(ctx, argv[0]);
  JSValue ret = module_load(ctx, path);

  return ret;
}

int main() {
  JSRuntime *rt = JS_NewRuntime();
  JSContext *ctx = JS_NewContext(rt);

  JSValue global_obj = JS_GetGlobalObject(ctx);

  JS_SetPropertyStr(
      ctx, global_obj, "print",
      JS_NewCFunction(ctx, print, "print", 1));
  JS_SetPropertyStr(
      ctx, global_obj, "my_import",
      JS_NewCFunction(ctx, my_import, "my_import", 1));

  const char *func = "print('hello'); const { bar } = my_import('bar.mjs'); bar('foo');";

  JSValue ret = JS_Eval(ctx, func, strlen(func), "my program", 0);

  if (JS_IsException(ret)) {
    JSValue ex = JS_GetException(cox);
    fprintf(stdout, "error: %s\n", JS_ToCString(ctx, ex));
  }

  JS_FreeContext(ctx);
  JS_FreeRuntime(rt);

  return 0;
}

my expected behavior would be to have it print:

hello
foo = foo

I get the hello from the JS_EvalFunction, and error: TypeError: Cannot convert undefined or null to object.

any help is much appreciated

[bnoordhuis]

This line is unsound:

JSModuleDef *module = (JSModuleDef *)JS_VALUE_GET_PTR(res2);

JS_EvalFunction returns a promise object, not a module object. Try this instead:

res2 = js_std_await(ctx, res2);
if (JS_IsException(res2)) {
    js_std_dump_error(ctx);
    exit(1);
}
JSModuleDef *module = JS_VALUE_GET_PTR(res2);

Awaiting promises recursively can deadlock so caveat emptor.

[JerrySievert]

hm, that doesn't seem to work either:

JSValue module_load(JSContext *ctx, const char *module_name) {
  size_t buf_len;
  const char *buf;

  buf = read_module(&buf_len, module_name);
  if (!buf) {
    fprintf(stderr, "could not load module '%s'", module_name);

    JS_ThrowReferenceError(ctx, "could not load module '%s'", module_name);

    return JS_EXCEPTION;
  }

  fprintf(stderr, "Read module '%s': %s (%ld)\n", module_name, buf, buf_len);

  /* compile the module */
  JSValue res = JS_Eval(ctx, buf, buf_len, module_name,
                        JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);

  if (JS_IsException(res)) {
    JSValue ex = JS_GetException(ctx);
    const char *err = JS_ToCString(ctx, ex);
    fprintf(stderr, "could not compile module '%s': %s", module_name, err);
    return JS_EXCEPTION;
  }

  JSValue res2 = JS_EvalFunction(ctx, res);

  if (JS_IsException(res2)) {
    const char *err = JS_ToCString(ctx, res2);
    fprintf(stderr, "could not evaluate module '%s': %s", module_name, err);
    return JS_EXCEPTION;
  }

  res2 = js_std_await(ctx, res2);
  if (JS_IsException(res2)) {
      js_std_dump_error(ctx);
      exit(1);
  }
  JSModuleDef *module = JS_VALUE_GET_PTR(res2);
  JSValue ns = JS_GetModuleNamespace(ctx, module);
  return ns;
}

again ends in EXC_BAD_ACCESS in JS_GetModuleNamespace.

[JerrySievert]

JSValue module_load(JSContext *ctx, const char *module_name) {
  size_t buf_len;
  const char *buf;

  buf = read_module(&buf_len, module_name);
  if (!buf) {
    fprintf(stderr, "could not load module '%s'", module_name);

    JS_ThrowReferenceError(ctx, "could not load module '%s'", module_name);

    return JS_EXCEPTION;
  }

  fprintf(stderr, "Read module '%s': %s (%ld)\n", module_name, buf, buf_len);

  /* compile the module */
  JSValue obj = JS_Eval(ctx, buf, buf_len, module_name,
                        JS_EVAL_TYPE_MODULE | JS_EVAL_FLAG_COMPILE_ONLY);

  if (JS_IsException(obj)) {
    JSValue ex = JS_GetException(ctx);
    const char *err = JS_ToCString(ctx, ex);
    fprintf(stderr, "could not compile module '%s': %s", module_name, err);
    JS_FreeCString(ctx, err);
    JS_FreeValue(ctx, ex);
    return JS_EXCEPTION;
  }

  /* resolve imports before evaluating */
  if (JS_ResolveModule(ctx, obj) < 0) {
    JS_FreeValue(ctx, obj);
    return JS_EXCEPTION;
  }

  /* evaluate the module — dup obj because EvalFunction consumes its argument */
  JSValue val = JS_EvalFunction(ctx, JS_DupValue(ctx, obj));
  val = js_std_await(ctx, val);

  if (JS_IsException(val)) {
    JS_FreeValue(ctx, obj);
    js_std_dump_error(ctx);
    return JS_EXCEPTION;
  }
  JS_FreeValue(ctx, val);

  /* get namespace from the *compiled* module object, not the eval result */
  JSModuleDef *m = JS_VALUE_GET_PTR(obj);
  JS_FreeValue(ctx, obj);
  JSValue ns = JS_GetModuleNamespace(ctx, m);
  return ns;
}

seems to work a little better, but I haven't tested all failure modes yet