Adds error enum templating support and adds new configuration parameters (#10)

* feat: add out_dirname_api flag

This allows the caller to configure which type of api should be used to
get the current directory - __dirname (classic node / commonjs) or
import.meta.module (esm)

* fix: add conversion between external module type -> internal module type

* refactor: rename OutputModuleType -> DirnameApi

* feat: add flag to allow disabling of uniffi dylib auto loading

This is important for situations where a uniffi dependency should be
conditionally loaded.

* feat: add check to ensure uniffi native code was loaded before performing a low level ffi function call

* fix: re-export uniffiLoad / uniffiUnload from -node script

* fix: update docs comments for uniffiLoad / uniffiUnload

* fix: add missing `type` prefixes in node script

* refactor: rename node.ts template to livekit-node.ts

* feat: parameterize output sys file name in templates

* refactor: use Default for flag enums

* feat: add out_import_extension parameter for changing import file name extension

* fix: make liftError use non hard coded error type

* refactor: rename template scripts to drop livekit prefix

* fix: remove unused imports

* docs: fix incorrect docstring

* docs: update docstring

* docs: add missing period

Author: 1egoman

src/bindings/filters.rs

@@ -1,6 +1,6 @@
 use askama::Result;
-use heck::{ToLowerCamelCase, ToPascalCase, ToUpperCamelCase, ToSnakeCase};
-use uniffi_bindgen::interface::{AsType, FfiDefinition, FfiType, Type};
+use heck::{ToLowerCamelCase, ToPascalCase, ToUpperCamelCase};
+use uniffi_bindgen::interface::{AsType, FfiType, Type};
 
 fn strip_comments(input: impl AsRef<str>) -> String {
     input.as_ref().replace("/* ", "").replace(" */", "")

src/bindings/generator.rs

@@ -4,63 +4,85 @@ use anyhow::{Context, Result};
 use askama::Template;
 use heck::ToKebabCase;
 
-use crate::bindings::filters;
+use crate::bindings::{filters, utils::{DirnameApi, ImportExtension}};
 
 pub struct Bindings {
     pub package_json_contents: String,
-    pub livekit_sys_template_contents: String,
+    pub sys_template_contents: String,
     pub node_ts_file_contents: String,
 }
 
 #[derive(Template)]
 #[template(escape = "none", path = "package.json")]
 struct PackageJsonTemplate<'ci> {
     ci: &'ci ComponentInterface,
-    node_ts_main_file_name: String,
 }
 
 impl<'ci> PackageJsonTemplate<'ci> {
-    pub fn new(ci: &'ci ComponentInterface, node_ts_main_file_name: &str) -> Self {
-        Self {
-            ci,
-            node_ts_main_file_name: node_ts_main_file_name.into(),
-        }
+    pub fn new(ci: &'ci ComponentInterface) -> Self {
+        Self { ci }
     }
 }
 
 #[derive(Template)]
-#[template(escape = "none", path = "livekit-sys.ts")]
-struct LivekitSysTemplate<'ci> {
+#[template(escape = "none", path = "sys.ts")]
+struct SysTemplate<'ci> {
     ci: &'ci ComponentInterface,
+
+    out_dirname_api: DirnameApi,
+    out_disable_auto_loading_lib: bool,
 }
 
-impl<'ci> LivekitSysTemplate<'ci> {
-    pub fn new(ci: &'ci ComponentInterface) -> Self {
-        Self { ci }
+impl<'ci> SysTemplate<'ci> {
+    pub fn new(
+        ci: &'ci ComponentInterface,
+        out_dirname_api: DirnameApi,
+        out_disable_auto_loading_lib: bool,
+    ) -> Self {
+        Self { ci, out_dirname_api, out_disable_auto_loading_lib }
     }
 }
 
 
 #[derive(Template)]
 #[template(escape = "none", path = "node.ts")]
-struct NodeTs<'ci> {
+struct NodeTsTemplate<'ci> {
     ci: &'ci ComponentInterface,
+    out_disable_auto_loading_lib: bool,
+    sys_ts_main_file_name: String,
+    out_import_extension: ImportExtension,
 }
 
-impl<'ci> NodeTs<'ci> {
-    pub fn new(ci: &'ci ComponentInterface) -> Self {
-        Self { ci }
+impl<'ci> NodeTsTemplate<'ci> {
+    pub fn new(
+        ci: &'ci ComponentInterface,
+        out_disable_auto_loading_lib: bool,
+        sys_ts_main_file_name: &str,
+        out_import_extension: ImportExtension
+    ) -> Self {
+        Self {
+            ci,
+            out_disable_auto_loading_lib,
+            sys_ts_main_file_name: sys_ts_main_file_name.to_string(),
+            out_import_extension,
+        }
     }
 }
 
-pub fn generate_node_bindings(ci: &ComponentInterface, node_ts_main_file_name: &str) -> Result<Bindings> {
-    let package_json_contents = PackageJsonTemplate::new(ci, node_ts_main_file_name).render().context("failed to render package.json template")?;
-    let livekit_sys_template_contents = LivekitSysTemplate::new(ci).render().context("failed to render livekit-sys.ts template")?;
-    let node_ts_file_contents = NodeTs::new(ci).render().context("failed to render node.ts template")?;
+pub fn generate_node_bindings(
+    ci: &ComponentInterface,
+    sys_ts_main_file_name: &str,
+    out_dirname_api: DirnameApi,
+    out_disable_auto_loading_lib: bool,
+    out_import_extension: ImportExtension,
+) -> Result<Bindings> {
+    let package_json_contents = PackageJsonTemplate::new(ci).render().context("failed to render package.json template")?;
+    let sys_template_contents = SysTemplate::new(ci, out_dirname_api, out_disable_auto_loading_lib).render().context("failed to render sys.ts template")?;
+    let node_ts_file_contents = NodeTsTemplate::new(ci, out_disable_auto_loading_lib, sys_ts_main_file_name, out_import_extension).render().context("failed to render node.ts template")?;
 
     Ok(Bindings {
         package_json_contents,
-        livekit_sys_template_contents,
+        sys_template_contents,
         node_ts_file_contents,
     })
 }

src/bindings/mod.rs

@@ -5,14 +5,23 @@ use serde::Deserialize;
 
 mod generator;
 mod filters;
+pub mod utils;
 
-use crate::{bindings::generator::{Bindings, generate_node_bindings}, utils::write_with_dirs};
+use crate::{bindings::generator::{generate_node_bindings, Bindings}, utils::write_with_dirs};
 
-pub struct NodeBindingGenerator {}
+pub struct NodeBindingGenerator {
+    out_dirname_api: utils::DirnameApi,
+    out_disable_auto_loading_lib: bool,
+    out_import_extension: utils::ImportExtension,
+}
 
 impl NodeBindingGenerator {
-    pub fn new() -> Self {
-        Self {}
+    pub fn new(
+        out_dirname_api: utils::DirnameApi,
+        out_disable_auto_loading_lib: bool,
+        out_import_extension: utils::ImportExtension,
+    ) -> Self {
+        Self { out_dirname_api, out_disable_auto_loading_lib, out_import_extension }
     }
 }
 
@@ -45,22 +54,28 @@ impl BindingGenerator for NodeBindingGenerator {
         components: &[uniffi_bindgen::Component<Self::Config>],
     ) -> Result<()> {
         for uniffi_bindgen::Component { ci, config: _, .. } in components {
-            let node_ts_main_file_name = format!("{}-node.ts", ci.namespace().to_kebab_case());
+            let sys_ts_main_file_name = format!("{}-sys", ci.namespace().to_kebab_case());
 
             let Bindings {
                 package_json_contents,
-                livekit_sys_template_contents,
+                sys_template_contents,
                 node_ts_file_contents,
-            } = generate_node_bindings(&ci, node_ts_main_file_name.as_str())?;
+            } = generate_node_bindings(
+                &ci,
+                sys_ts_main_file_name.as_str(),
+                self.out_dirname_api.clone(),
+                self.out_disable_auto_loading_lib,
+                self.out_import_extension.clone(),
+            )?;
 
             let package_json_path = settings.out_dir.join("package.json");
             write_with_dirs(&package_json_path, package_json_contents)?;
 
-            let node_ts_file_path = settings.out_dir.join(node_ts_main_file_name);
+            let node_ts_file_path = settings.out_dir.join(format!("{}-node.ts", ci.namespace().to_kebab_case()));
             write_with_dirs(&node_ts_file_path, node_ts_file_contents)?;
 
-            let livekit_sys_template_path = settings.out_dir.join(format!("{}-sys.ts", ci.namespace().to_kebab_case()));
-            write_with_dirs(&livekit_sys_template_path, livekit_sys_template_contents)?;
+            let sys_template_path = settings.out_dir.join(format!("{sys_ts_main_file_name}.ts"));
+            write_with_dirs(&sys_template_path, sys_template_contents)?;
         }
 
         Ok(())

src/lib.rs

@@ -5,6 +5,40 @@ use clap::Parser;
 mod bindings;
 mod utils;
 
+#[derive(Debug, Clone, Default, clap::ValueEnum)]
+enum OutputDirnameApi {
+    #[default]
+    Dirname,
+    ImportMetaUrl,
+}
+
+impl Into<bindings::utils::DirnameApi> for OutputDirnameApi {
+    fn into(self) -> bindings::utils::DirnameApi {
+        match self {
+            OutputDirnameApi::ImportMetaUrl => bindings::utils::DirnameApi::ImportMetaUrl,
+            OutputDirnameApi::Dirname => bindings::utils::DirnameApi::Dirname,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, clap::ValueEnum)]
+enum OutputImportExtension {
+    #[default]
+    None,
+    Ts,
+    Js,
+}
+
+impl Into<bindings::utils::ImportExtension> for OutputImportExtension {
+    fn into(self) -> bindings::utils::ImportExtension {
+        match self {
+            OutputImportExtension::None => bindings::utils::ImportExtension::None,
+            OutputImportExtension::Ts => bindings::utils::ImportExtension::Ts,
+            OutputImportExtension::Js => bindings::utils::ImportExtension::Js,
+        }
+    }
+}
+
 /// UniFFI binding generator for Node.js
 #[derive(Parser, Debug)]
 #[command(version, about, long_about = None)]
@@ -20,6 +54,27 @@ pub struct Args {
     #[arg(long, default_value = "livekit_uniffi")]
     crate_name: String,
 
+    /// The set of buildin apis which should be used to get the current
+    /// directory - `__dirname` or `import.meta.url`.
+    #[arg(long, value_enum, default_value_t=OutputDirnameApi::default())]
+    out_dirname_api: OutputDirnameApi,
+
+    /// If specified, the dylib/so/dll native dependency won't be automatically loaded
+    /// when the bindgen is imported. If this flag is set, explicit `uniffiLoad` / `uniffiUnload`
+    /// will be exported from the generated package which must be called before any uniffi calls
+    /// are made.
+    ///
+    /// Use this if you want to only load a bindgen sometimes (ie, it is an optional dependency).
+    #[arg(long, action)]
+    out_disable_auto_load_lib: bool,
+
+    /// Changes the extension used in `import`s within the final generated output. This exists
+    /// because depending on packaging / tsc configuration, the import path extensions may be
+    /// expected to end in different extensions. For example, tsc often requires .js extensions
+    /// on .ts files it imports, etc.
+    #[arg(long, action, value_enum, default_value_t=OutputImportExtension::default())]
+    out_import_extension: OutputImportExtension,
+
     /// Config file override.
     #[arg(short, long)]
     config_override: Option<Utf8PathBuf>,
@@ -32,7 +87,11 @@ pub fn run(args: Args) -> Result<()> {
         let metadata = cmd.exec().context("error running cargo metadata")?;
         CrateConfigSupplier::from(metadata)
     };
-    let node_binding_generator = bindings::NodeBindingGenerator::new();
+    let node_binding_generator = bindings::NodeBindingGenerator::new(
+        args.out_dirname_api.into(),
+        args.out_disable_auto_load_lib,
+        args.out_import_extension.into(),
+    );
 
     uniffi_bindgen::library_mode::generate_bindings(
         &args.lib_source,

templates/macros.ts

@@ -12,4 +12,16 @@
 {{ s | typescript_docstring(indent_level) }}
 {%- else %}
 {%- endmatch %}
-{%- endmacro %}
+{%- endmacro %}
+
+{%- macro import_file_path(file_name) -%}
+  {{- file_name -}}
+  {%- match out_import_extension -%}
+    {%- when ImportExtension::None -%}
+      {# explicitly empty #}
+    {%- when ImportExtension::Ts -%}
+      .ts
+    {%- when ImportExtension::Js -%}
+      .js
+  {%- endmatch -%}
+{%- endmacro -%}

templates/node.ts

@@ -129,7 +129,7 @@
     {%- match func_def.throws_type() -%}
       {%- when Some(err) -%}
         uniffiCaller.rustCallWithError(
-          /*liftError:*/ FfiConverterTypeAccessTokenError.lift.bind(FfiConverterTypeAccessTokenError), // FIXME: where does this error type come from?
+          /*liftError:*/ {{err | typescript_ffi_converter_name}}.lift.bind({{err | typescript_ffi_converter_name}}),
           /*caller:*/ (callStatus) => {
       {%- else -%}
         uniffiCaller.rustCall(
@@ -216,7 +216,7 @@ import {
 
 import {
   DataType,
-  JsExternal,
+  type JsExternal,
   open, /* close, */
   define,
   load,
@@ -229,7 +229,7 @@ import {
   freePointer,
   isNullPointer,
   PointerType,
-  FieldType,
+  type FieldType,
 } from 'ffi-rs';
 
 
@@ -254,8 +254,11 @@ import FFI_DYNAMIC_LIB, {
       {%- else -%}
     {%- endmatch %}
   {%- endfor %}
-} from './{{ci.namespace().to_kebab_case()}}-sys';
+} from './{%- call ts::import_file_path(sys_ts_main_file_name) -%}';
 
+{% if out_disable_auto_loading_lib %}
+export { uniffiLoad, uniffiUnload } from './{%- call ts::import_file_path(sys_ts_main_file_name) -%}';
+{% endif %}
 
 
 

templates/package.json

@@ -1,8 +1,6 @@
 {
   "name": "lib{{ ci.crate_name().to_kebab_case() }}",
   "description": "Uniffi wrapper around the {{ ci.crate_name() }} rust crate.",
-  "version": "0.0.1",
-  {# "main": "{{ node_ts_main_file_name }}.js", FIXME: should this be set? But then I'd need to define a whole build system in here, and that is probably going too far... -#}
   "dependencies": {
     "ffi-rs": "^1.3.0",
     "ref-napi": "^3.0.3",