tranfi 0.1.2 → 0.2.1

package/csrc/wasm_api.c

@@ -10,6 +10,7 @@
 #endif
 
 #include "tranfi.h"
+#include "internal.h"
 #include "dsl.h"
 #include "recipes.h"
 #include <stdlib.h>
@@ -34,15 +35,35 @@ static tf_pipeline *get_handle(int h) {
     return handles[h];
 }
 
+static int wasm_validate_buffer(const void *ptr, int len, const char *what) {
+    if (len < 0) {
+        tf_set_last_error(what ? what : "invalid WASM buffer length");
+        return 0;
+    }
+    if (len > 0 && !ptr) {
+        tf_set_last_error(what ? what : "invalid WASM buffer pointer");
+        return 0;
+    }
+    return 1;
+}
+
 #ifdef __EMSCRIPTEN__
 #define EXPORT EMSCRIPTEN_KEEPALIVE
 #else
 #define EXPORT
 #endif
 
-EXPORT
-int wasm_pipeline_create(const char *json, int len) {
-    tf_pipeline *p = tf_pipeline_create(json, (size_t)len);
+static int wasm_pipeline_create_policy(const char *json, int len,
+                                       int allow_fs, int allow_spill,
+                                       int allow_rules_file, const char *workspace_root) {
+    if (!wasm_validate_buffer(json, len, "invalid WASM plan buffer")) return -1;
+    tf_host_policy policy = {0};
+    policy.allow_fs = allow_fs != 0;
+    policy.allow_spill = allow_spill != 0;
+    policy.allow_rules_file = allow_rules_file != 0;
+    policy.allow_blocking = true;
+    policy.workspace_root = workspace_root && workspace_root[0] ? workspace_root : NULL;
+    tf_pipeline *p = tf_pipeline_create_with_host_policy(json, (size_t)len, &policy);
     if (!p) return -1;
     int h = alloc_handle(p);
     if (h < 0) {
@@ -52,13 +73,41 @@ int wasm_pipeline_create(const char *json, int len) {
     return h;
 }
 
+EXPORT
+int wasm_pipeline_create(const char *json, int len) {
+    return wasm_pipeline_create_policy(json, len, 0, 0, 0, NULL);
+}
+
+EXPORT
+int wasm_pipeline_create_with_policy(const char *json, int len, int allow_fs,
+                                     int allow_spill, int allow_rules_file,
+                                     const char *workspace_root) {
+    return wasm_pipeline_create_policy(json, len, allow_fs, allow_spill,
+                                       allow_rules_file, workspace_root);
+}
+
 EXPORT
 int wasm_pipeline_push(int handle, const uint8_t *data, int len) {
     tf_pipeline *p = get_handle(handle);
     if (!p) return -1;
+    if (!wasm_validate_buffer(data, len, "invalid WASM input buffer")) return -1;
     return tf_pipeline_push(p, data, (size_t)len);
 }
 
+EXPORT
+int wasm_pipeline_flush_input(int handle) {
+    tf_pipeline *p = get_handle(handle);
+    if (!p) return -1;
+    return tf_pipeline_flush_input(p);
+}
+
+EXPORT
+int wasm_pipeline_set_source_name(int handle, const char *name) {
+    tf_pipeline *p = get_handle(handle);
+    if (!p) return -1;
+    return tf_pipeline_set_source_name(p, name);
+}
+
 EXPORT
 int wasm_pipeline_finish(int handle) {
     tf_pipeline *p = get_handle(handle);
@@ -66,10 +115,18 @@ int wasm_pipeline_finish(int handle) {
     return tf_pipeline_finish(p);
 }
 
+EXPORT
+int wasm_pipeline_finish_step(int handle) {
+    tf_pipeline *p = get_handle(handle);
+    if (!p) return -1;
+    return tf_pipeline_finish_step(p);
+}
+
 EXPORT
 int wasm_pipeline_pull(int handle, int channel, uint8_t *buf, int buf_len) {
     tf_pipeline *p = get_handle(handle);
     if (!p) return 0;
+    if (!wasm_validate_buffer(buf, buf_len, "invalid WASM output buffer")) return -1;
     return (int)tf_pipeline_pull(p, channel, buf, (size_t)buf_len);
 }
 
@@ -98,16 +155,14 @@ void wasm_pipeline_free(int handle) {
  */
 EXPORT
 char *wasm_compile_dsl(const char *dsl, int len) {
+    if (!wasm_validate_buffer(dsl, len, "invalid WASM DSL buffer")) return NULL;
     char *error = NULL;
-    tf_ir_plan *plan = tf_dsl_parse(dsl, (size_t)len, &error);
-    if (!plan) {
-        /* Store error so JS can retrieve it via wasm_pipeline_error(-1) */
-        (void)error; /* error accessible via tf_last_error() */
+    char *json = tf_compile_dsl(dsl, (size_t)len, &error);
+    if (!json) {
+        tf_set_last_error(error ? error : "DSL compile failed");
         free(error);
         return NULL;
     }
-    char *json = tf_ir_plan_to_json(plan);
-    tf_ir_plan_destroy(plan);
     return json;
 }
 
@@ -118,8 +173,14 @@ char *wasm_compile_dsl(const char *dsl, int len) {
  */
 EXPORT
 char *wasm_compile_to_sql(const char *dsl, int len) {
+    if (!wasm_validate_buffer(dsl, len, "invalid WASM DSL buffer")) return NULL;
     char *error = NULL;
     char *sql = tf_compile_to_sql(dsl, (size_t)len, &error);
+    if (!sql) {
+        tf_set_last_error(error ? error : "SQL compile failed");
+        free(error);
+        return NULL;
+    }
     free(error);
     return sql;
 }

package/napi_api.c

@@ -8,6 +8,7 @@
 #include "tranfi.h"
 #include "dsl.h"
 #include "recipes.h"
+#include "napi_transform.h"
 #include <stdlib.h>
 #include <string.h>
 
@@ -20,10 +21,87 @@
         }                                                       \
     } while (0)
 
-/*ాcreate_pipeline(planJson: string) → External */
+
+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 = 1;
-    napi_value argv[1];
+    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) {
@@ -31,13 +109,21 @@ static napi_value napi_create_pipeline(napi_env env, napi_callback_info info) {
         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(json, 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();
@@ -71,6 +157,66 @@ static napi_value napi_push(napi_env env, napi_callback_info info) {
     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;
@@ -88,6 +234,26 @@ static napi_value napi_finish(napi_env env, napi_callback_info info) {
     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;
@@ -124,6 +290,46 @@ static napi_value napi_pull(napi_env env, napi_callback_info info) {
     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;
@@ -184,18 +390,15 @@ static napi_value napi_compile_dsl(napi_env env, napi_callback_info info) {
     NAPI_CALL(env, napi_get_value_string_utf8(env, argv[0], dsl, str_len + 1, &str_len));
 
     char *error = NULL;
-    tf_ir_plan *plan = tf_dsl_parse(dsl, str_len, &error);
+    char *json = tf_compile_dsl(dsl, str_len, &error);
     free(dsl);
 
-    if (!plan) {
-        napi_throw_error(env, NULL, error ? error : "DSL parse failed");
+    if (!json) {
+        napi_throw_error(env, NULL, error ? error : "DSL compile failed");
         free(error);
         return NULL;
     }
 
-    char *json = tf_ir_plan_to_json(plan);
-    tf_ir_plan_destroy(plan);
-
     napi_value result;
     NAPI_CALL(env, napi_create_string_utf8(env, json, strlen(json), &result));
     free(json);
@@ -306,8 +509,12 @@ 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},
@@ -319,7 +526,8 @@ static napi_value init(napi_env env, napi_value exports) {
         {"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, 14, props));
+    NAPI_CALL(env, napi_define_properties(env, exports, 18, props));
+    NAPI_CALL(env, tranfi_napi_define_transform(env, exports));
     return exports;
 }