tranfi 0.0.2 → 0.2.0

package/napi_api.c

@@ -0,0 +1,534 @@
+/*
+ * napi_api.c — Node.js N-API addon for Tranfi.
+ *
+ * Exposes the C pipeline API as native Node functions.
+ */
+
+#include <node_api.h>
+#include "tranfi.h"
+#include "dsl.h"
+#include "recipes.h"
+#include "napi_transform.h"
+#include <stdlib.h>
+#include <string.h>
+
+#define NAPI_CALL(env, call)                                    \
+    do {                                                        \
+        napi_status status = (call);                            \
+        if (status != napi_ok) {                                \
+            napi_throw_error(env, NULL, "N-API call failed");   \
+            return NULL;                                        \
+        }                                                       \
+    } while (0)
+
+
+static int get_named_bool(napi_env env, napi_value obj, const char *name, bool default_value, bool *out) {
+    bool has = false;
+    napi_status st = napi_has_named_property(env, obj, name, &has);
+    if (st != napi_ok || !has) { *out = default_value; return 0; }
+    napi_value value;
+    st = napi_get_named_property(env, obj, name, &value);
+    if (st != napi_ok) { *out = default_value; return 0; }
+    napi_valuetype type;
+    st = napi_typeof(env, value, &type);
+    if (st != napi_ok || type == napi_undefined || type == napi_null) { *out = default_value; return 0; }
+    if (type != napi_boolean) {
+        napi_throw_type_error(env, NULL, "host policy option must be boolean");
+        return -1;
+    }
+    bool b = false;
+    st = napi_get_value_bool(env, value, &b);
+    if (st != napi_ok) return -1;
+    *out = b;
+    return 0;
+}
+
+static int get_named_bool_alias(napi_env env, napi_value obj, const char *camel,
+                                const char *snake, bool default_value, bool *out) {
+    bool has = false;
+    if (napi_has_named_property(env, obj, camel, &has) == napi_ok && has)
+        return get_named_bool(env, obj, camel, default_value, out);
+    return get_named_bool(env, obj, snake, default_value, out);
+}
+
+static char *get_named_string(napi_env env, napi_value obj, const char *name) {
+    bool has = false;
+    if (napi_has_named_property(env, obj, name, &has) != napi_ok || !has) return NULL;
+    napi_value value;
+    if (napi_get_named_property(env, obj, name, &value) != napi_ok) return NULL;
+    napi_valuetype type;
+    if (napi_typeof(env, value, &type) != napi_ok || type == napi_undefined || type == napi_null) return NULL;
+    if (type != napi_string) {
+        napi_throw_type_error(env, NULL, "workspaceRoot must be a string");
+        return (char *)-1;
+    }
+    size_t len = 0;
+    if (napi_get_value_string_utf8(env, value, NULL, 0, &len) != napi_ok) return (char *)-1;
+    char *s = malloc(len + 1);
+    if (!s) return (char *)-1;
+    if (napi_get_value_string_utf8(env, value, s, len + 1, &len) != napi_ok) {
+        free(s);
+        return (char *)-1;
+    }
+    return s;
+}
+
+static int parse_host_policy_options(napi_env env, napi_value value, tf_host_policy *policy,
+                                     char **workspace_root) {
+    memset(policy, 0, sizeof(*policy));
+    policy->allow_blocking = true;
+    *workspace_root = NULL;
+    if (!value) return 0;
+    napi_valuetype type;
+    if (napi_typeof(env, value, &type) != napi_ok || type == napi_undefined || type == napi_null) return 0;
+    if (type != napi_object) {
+        napi_throw_type_error(env, NULL, "createPipeline options must be an object");
+        return -1;
+    }
+    if (get_named_bool_alias(env, value, "allowFs", "allow_fs", false, &policy->allow_fs) != 0) return -1;
+    if (get_named_bool_alias(env, value, "allowNet", "allow_net", false, &policy->allow_net) != 0) return -1;
+    if (get_named_bool_alias(env, value, "allowSpill", "allow_spill", false, &policy->allow_spill) != 0) return -1;
+    if (get_named_bool_alias(env, value, "allowRulesFile", "allow_rules_file", false, &policy->allow_rules_file) != 0) return -1;
+    if (get_named_bool_alias(env, value, "allowBlocking", "allow_blocking", true, &policy->allow_blocking) != 0) return -1;
+    *workspace_root = get_named_string(env, value, "workspaceRoot");
+    if (*workspace_root == (char *)-1) { *workspace_root = NULL; return -1; }
+    if (!*workspace_root) *workspace_root = get_named_string(env, value, "workspace_root");
+    if (*workspace_root == (char *)-1) { *workspace_root = NULL; return -1; }
+    policy->workspace_root = *workspace_root && (*workspace_root)[0] ? *workspace_root : NULL;
+    return 0;
+}
+
+/* createPipeline(planJson: string, options?: HostPolicy) → External */
+static napi_value napi_create_pipeline(napi_env env, napi_callback_info info) {
+    size_t argc = 2;
+    napi_value argv[2] = {0};
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    if (argc < 1) {
+        napi_throw_error(env, NULL, "createPipeline requires plan JSON string");
+        return NULL;
+    }
+
+    tf_host_policy policy;
+    char *workspace_root = NULL;
+    if (parse_host_policy_options(env, argc >= 2 ? argv[1] : NULL, &policy, &workspace_root) != 0) {
+        free(workspace_root);
+        return NULL;
+    }
+
+    size_t str_len;
+    NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], NULL, 0, &str_len));
+    char *json = malloc(str_len + 1);
+    NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], json, str_len + 1, &str_len));
+
+    tf_pipeline *p = tf_pipeline_create_with_host_policy(json, str_len, &policy);
+    free(json);
+    free(workspace_root);
+
+    if (!p) {
+        const char *err = tf_last_error();
+        napi_throw_error(env, NULL, err ? err : "failed to create pipeline");
+        return NULL;
+    }
+
+    napi_value external;
+    NAPI_CALL(env, napi_create_external(env, p, NULL, NULL, &external));
+    return external;
+}
+
+/* push(pipeline: External, data: Buffer) → void */
+static napi_value napi_push(napi_env env, napi_callback_info info) {
+    size_t argc = 2;
+    napi_value argv[2];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    tf_pipeline *p;
+    NAPI_CALL(env, napi_get_value_external(env, argv[0], (void **)&p));
+
+    uint8_t *data;
+    size_t len;
+    NAPI_CALL(env, napi_get_buffer_info(env, argv[1], (void **)&data, &len));
+
+    int rc = tf_pipeline_push(p, data, len);
+    if (rc != 0) {
+        const char *err = tf_pipeline_error(p);
+        napi_throw_error(env, NULL, err ? err : "push failed");
+    }
+    return NULL;
+}
+
+/* flushInput(pipeline: External) → void */
+static napi_value napi_flush_input(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    tf_pipeline *p;
+    NAPI_CALL(env, napi_get_value_external(env, argv[0], (void **)&p));
+
+    int rc = tf_pipeline_flush_input(p);
+    if (rc != 0) {
+        const char *err = tf_pipeline_error(p);
+        napi_throw_error(env, NULL, err ? err : "input flush failed");
+    }
+    return NULL;
+}
+
+/* setSourceName(pipeline: External, name?: string | null) → void */
+static napi_value napi_set_source_name(napi_env env, napi_callback_info info) {
+    size_t argc = 2;
+    napi_value argv[2];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    if (argc < 1) {
+        napi_throw_error(env, NULL, "setSourceName requires pipeline");
+        return NULL;
+    }
+
+    tf_pipeline *p;
+    NAPI_CALL(env, napi_get_value_external(env, argv[0], (void **)&p));
+
+    char *name = NULL;
+    if (argc >= 2) {
+        napi_valuetype type;
+        NAPI_CALL(env, napi_typeof(env, argv[1], &type));
+        if (type != napi_null && type != napi_undefined) {
+            if (type != napi_string) {
+                napi_throw_error(env, NULL, "source name must be a string, null, or undefined");
+                return NULL;
+            }
+            size_t str_len = 0;
+            NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], NULL, 0, &str_len));
+            name = malloc(str_len + 1);
+            if (!name) {
+                napi_throw_error(env, NULL, "out of memory");
+                return NULL;
+            }
+            NAPI_CALL(env, napi_get_value_string_utf8(env, argv[1], name, str_len + 1, &str_len));
+        }
+    }
+
+    int rc = tf_pipeline_set_source_name(p, name);
+    free(name);
+    if (rc != 0) {
+        const char *err = tf_pipeline_error(p);
+        napi_throw_error(env, NULL, err ? err : "set source name failed");
+    }
+    return NULL;
+}
+
+/* finish(pipeline: External) → void */
+static napi_value napi_finish(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    tf_pipeline *p;
+    NAPI_CALL(env, napi_get_value_external(env, argv[0], (void **)&p));
+
+    int rc = tf_pipeline_finish(p);
+    if (rc != 0) {
+        const char *err = tf_pipeline_error(p);
+        napi_throw_error(env, NULL, err ? err : "finish failed");
+    }
+    return NULL;
+}
+
+/* finishStep(pipeline: External) → boolean done */
+static napi_value napi_finish_step(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    tf_pipeline *p;
+    NAPI_CALL(env, napi_get_value_external(env, argv[0], (void **)&p));
+
+    int rc = tf_pipeline_finish_step(p);
+    if (rc == TF_ERROR) {
+        const char *err = tf_pipeline_error(p);
+        napi_throw_error(env, NULL, err ? err : "finish failed");
+        return NULL;
+    }
+    napi_value result;
+    NAPI_CALL(env, napi_get_boolean(env, rc == TF_DONE, &result));
+    return result;
+}
+
+/* pull(pipeline: External, channel: number) → Buffer */
+static napi_value napi_pull(napi_env env, napi_callback_info info) {
+    size_t argc = 2;
+    napi_value argv[2];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    tf_pipeline *p;
+    NAPI_CALL(env, napi_get_value_external(env, argv[0], (void **)&p));
+
+    int32_t channel;
+    NAPI_CALL(env, napi_get_value_int32(env, argv[1], &channel));
+
+    /* Pull all available data */
+    size_t total = 0;
+    size_t cap = 65536;
+    uint8_t *result = malloc(cap);
+    uint8_t buf[65536];
+
+    for (;;) {
+        size_t n = tf_pipeline_pull(p, channel, buf, sizeof(buf));
+        if (n == 0) break;
+        if (total + n > cap) {
+            while (cap < total + n) cap *= 2;
+            result = realloc(result, cap);
+        }
+        memcpy(result + total, buf, n);
+        total += n;
+    }
+
+    napi_value buffer;
+    void *buf_data;
+    NAPI_CALL(env, napi_create_buffer_copy(env, total, result, &buf_data, &buffer));
+    free(result);
+    return buffer;
+}
+
+/* pullChunk(pipeline: External, channel: number, maxBytes?: number) → Buffer */
+static napi_value napi_pull_chunk(napi_env env, napi_callback_info info) {
+    size_t argc = 3;
+    napi_value argv[3];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    if (argc < 2) {
+        napi_throw_error(env, NULL, "pullChunk requires pipeline and channel");
+        return NULL;
+    }
+
+    tf_pipeline *p;
+    NAPI_CALL(env, napi_get_value_external(env, argv[0], (void **)&p));
+
+    int32_t channel;
+    NAPI_CALL(env, napi_get_value_int32(env, argv[1], &channel));
+
+    uint32_t max_bytes = 65536;
+    if (argc >= 3) {
+        NAPI_CALL(env, napi_get_value_uint32(env, argv[2], &max_bytes));
+        if (max_bytes == 0) {
+            napi_throw_error(env, NULL, "pullChunk maxBytes must be positive");
+            return NULL;
+        }
+    }
+
+    uint8_t *tmp = malloc((size_t)max_bytes);
+    if (!tmp) {
+        napi_throw_error(env, NULL, "out of memory");
+        return NULL;
+    }
+
+    size_t n = tf_pipeline_pull(p, channel, tmp, (size_t)max_bytes);
+    napi_value buffer;
+    void *buf_data;
+    NAPI_CALL(env, napi_create_buffer_copy(env, n, tmp, &buf_data, &buffer));
+    free(tmp);
+    return buffer;
+}
+
+/* free(pipeline: External) → void */
+static napi_value napi_free_pipeline(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    tf_pipeline *p;
+    NAPI_CALL(env, napi_get_value_external(env, argv[0], (void **)&p));
+
+    tf_pipeline_free(p);
+    return NULL;
+}
+
+/* version() → string */
+static napi_value napi_tranfi_version(napi_env env, napi_callback_info info) {
+    (void)info;
+    const char *v = tf_version();
+    napi_value result;
+    NAPI_CALL(env, napi_create_string_utf8(env, v, strlen(v), &result));
+    return result;
+}
+
+/* error(pipeline: External) → string | null */
+static napi_value napi_tranfi_error(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    tf_pipeline *p;
+    NAPI_CALL(env, napi_get_value_external(env, argv[0], (void **)&p));
+
+    const char *err = tf_pipeline_error(p);
+    if (!err) {
+        napi_value null_val;
+        napi_get_null(env, &null_val);
+        return null_val;
+    }
+
+    napi_value result;
+    NAPI_CALL(env, napi_create_string_utf8(env, err, strlen(err), &result));
+    return result;
+}
+
+/* compileDsl(dslString: string) → string (plan JSON) */
+static napi_value napi_compile_dsl(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    if (argc < 1) {
+        napi_throw_error(env, NULL, "compileDsl requires DSL string");
+        return NULL;
+    }
+
+    size_t str_len;
+    NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], NULL, 0, &str_len));
+    char *dsl = malloc(str_len + 1);
+    NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], dsl, str_len + 1, &str_len));
+
+    char *error = NULL;
+    char *json = tf_compile_dsl(dsl, str_len, &error);
+    free(dsl);
+
+    if (!json) {
+        napi_throw_error(env, NULL, error ? error : "DSL compile failed");
+        free(error);
+        return NULL;
+    }
+
+    napi_value result;
+    NAPI_CALL(env, napi_create_string_utf8(env, json, strlen(json), &result));
+    free(json);
+    return result;
+}
+
+/* compileToSql(dslString: string) → string (SQL query) */
+static napi_value napi_compile_to_sql(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+
+    if (argc < 1) {
+        napi_throw_error(env, NULL, "compileToSql requires DSL string");
+        return NULL;
+    }
+
+    size_t str_len;
+    NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], NULL, 0, &str_len));
+    char *dsl = malloc(str_len + 1);
+    NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], dsl, str_len + 1, &str_len));
+
+    char *error = NULL;
+    char *sql = tf_compile_to_sql(dsl, str_len, &error);
+    free(dsl);
+
+    if (!sql) {
+        napi_throw_error(env, NULL, error ? error : "SQL compilation failed");
+        free(error);
+        return NULL;
+    }
+
+    napi_value result;
+    NAPI_CALL(env, napi_create_string_utf8(env, sql, strlen(sql), &result));
+    tf_string_free(sql);
+    return result;
+}
+
+/* recipeCount() → number */
+static napi_value napi_recipe_count(napi_env env, napi_callback_info info) {
+    (void)info;
+    napi_value result;
+    NAPI_CALL(env, napi_create_uint32(env, (uint32_t)tf_recipe_count(), &result));
+    return result;
+}
+
+/* recipeName(index: number) → string | null */
+static napi_value napi_recipe_name(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+    uint32_t index;
+    NAPI_CALL(env, napi_get_value_uint32(env, argv[0], &index));
+    const char *s = tf_recipe_name(index);
+    if (!s) { napi_value n; napi_get_null(env, &n); return n; }
+    napi_value result;
+    NAPI_CALL(env, napi_create_string_utf8(env, s, strlen(s), &result));
+    return result;
+}
+
+/* recipeDsl(index: number) → string | null */
+static napi_value napi_recipe_dsl(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+    uint32_t index;
+    NAPI_CALL(env, napi_get_value_uint32(env, argv[0], &index));
+    const char *s = tf_recipe_dsl(index);
+    if (!s) { napi_value n; napi_get_null(env, &n); return n; }
+    napi_value result;
+    NAPI_CALL(env, napi_create_string_utf8(env, s, strlen(s), &result));
+    return result;
+}
+
+/* recipeDescription(index: number) → string | null */
+static napi_value napi_recipe_description(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+    uint32_t index;
+    NAPI_CALL(env, napi_get_value_uint32(env, argv[0], &index));
+    const char *s = tf_recipe_description(index);
+    if (!s) { napi_value n; napi_get_null(env, &n); return n; }
+    napi_value result;
+    NAPI_CALL(env, napi_create_string_utf8(env, s, strlen(s), &result));
+    return result;
+}
+
+/* recipeFindDsl(name: string) → string | null */
+static napi_value napi_recipe_find_dsl(napi_env env, napi_callback_info info) {
+    size_t argc = 1;
+    napi_value argv[1];
+    NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
+    size_t str_len;
+    NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], NULL, 0, &str_len));
+    char *name = malloc(str_len + 1);
+    NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], name, str_len + 1, &str_len));
+    const char *dsl = tf_recipe_find_dsl(name);
+    free(name);
+    if (!dsl) { napi_value n; napi_get_null(env, &n); return n; }
+    napi_value result;
+    NAPI_CALL(env, napi_create_string_utf8(env, dsl, strlen(dsl), &result));
+    return result;
+}
+
+/* Module init */
+static napi_value init(napi_env env, napi_value exports) {
+    napi_property_descriptor props[] = {
+        {"createPipeline",    NULL, napi_create_pipeline,    NULL, NULL, NULL, napi_default, NULL},
+        {"push",              NULL, napi_push,               NULL, NULL, NULL, napi_default, NULL},
+        {"flushInput",        NULL, napi_flush_input,        NULL, NULL, NULL, napi_default, NULL},
+        {"setSourceName",     NULL, napi_set_source_name,    NULL, NULL, NULL, napi_default, NULL},
+        {"finish",            NULL, napi_finish,             NULL, NULL, NULL, napi_default, NULL},
+        {"finishStep",        NULL, napi_finish_step,        NULL, NULL, NULL, napi_default, NULL},
+        {"pull",              NULL, napi_pull,               NULL, NULL, NULL, napi_default, NULL},
+        {"pullChunk",         NULL, napi_pull_chunk,         NULL, NULL, NULL, napi_default, NULL},
+        {"free",              NULL, napi_free_pipeline,      NULL, NULL, NULL, napi_default, NULL},
+        {"version",           NULL, napi_tranfi_version,     NULL, NULL, NULL, napi_default, NULL},
+        {"error",             NULL, napi_tranfi_error,       NULL, NULL, NULL, napi_default, NULL},
+        {"compileDsl",        NULL, napi_compile_dsl,        NULL, NULL, NULL, napi_default, NULL},
+        {"compileToSql",      NULL, napi_compile_to_sql,     NULL, NULL, NULL, napi_default, NULL},
+        {"recipeCount",       NULL, napi_recipe_count,       NULL, NULL, NULL, napi_default, NULL},
+        {"recipeName",        NULL, napi_recipe_name,        NULL, NULL, NULL, napi_default, NULL},
+        {"recipeDsl",         NULL, napi_recipe_dsl,         NULL, NULL, NULL, napi_default, NULL},
+        {"recipeDescription", NULL, napi_recipe_description, NULL, NULL, NULL, napi_default, NULL},
+        {"recipeFindDsl",     NULL, napi_recipe_find_dsl,    NULL, NULL, NULL, napi_default, NULL},
+    };
+    NAPI_CALL(env, napi_define_properties(env, exports, 18, props));
+    NAPI_CALL(env, tranfi_napi_define_transform(env, exports));
+    return exports;
+}
+
+NAPI_MODULE(NODE_GYP_MODULE_NAME, init)