Skip to content

Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.

fix(extraction): fold local URLs without changing topic identities

Martin Vogel77bc4927f979
diff --git a/Makefile.cbm b/Makefile.cbm
index c0e0aa4a0..f1402881b 100644
--- a/Makefile.cbm
+++ b/Makefile.cbm
@@ -366,6 +366,7 @@ EXTRACTION_SRCS = \
$(CBM_DIR)/extract_imports.c \
$(CBM_DIR)/extract_usages.c \
$(CBM_DIR)/extract_unified.c \
+ $(CBM_DIR)/extract_url_fold.c \
$(CBM_DIR)/extract_semantic.c \
$(CBM_DIR)/extract_type_refs.c \
$(CBM_DIR)/extract_type_assigns.c \
diff --git a/internal/cbm/cbm.h b/internal/cbm/cbm.h
index f9d42ec36..e9dad3427 100644
--- a/internal/cbm/cbm.h
+++ b/internal/cbm/cbm.h
@@ -309,9 +309,10 @@ typedef struct {
/* Argument captured from a call expression */
typedef struct {
const char *expr; // raw expression text ("payload.info", "MY_URL", "'hello'")
- const char *value; // resolved string value or NULL (constant propagation)
+ const char *value; // raw resolved string value or NULL (constant propagation)
const char *keyword; // keyword name if keyword arg ("url", "topic_id"), NULL if positional
int index; // positional index (0-based)
+ const char *url_value; // URL projection when different; never a topic/string identity
} CBMCallArg;
#define CBM_MAX_CALL_ARGS 8
@@ -868,6 +869,7 @@ typedef struct {
typedef struct {
const char *names[CBM_MAX_STRING_CONSTANTS];
const char *values[CBM_MAX_STRING_CONSTANTS];
+ const char *url_values[CBM_MAX_STRING_CONSTANTS]; // extraction-only URL projections
bool is_url_builder[CBM_MAX_STRING_CONSTANTS];
int count;
} CBMStringConstantMap;
diff --git a/internal/cbm/extract_calls.c b/internal/cbm/extract_calls.c
index a86367b6b..112f4a8cf 100644
--- a/internal/cbm/extract_calls.c
+++ b/internal/cbm/extract_calls.c
@@ -4,6 +4,7 @@
#include "lang_specs.h"
#include "macro_table.h"
#include "extract_unified.h"
+#include "extract_url_fold.h" // URL constant folding (#706, #1147)
#include "foundation/constants.h"
#include "extract_node_stack.h"
#include "service_patterns.h" // cbm_service_pattern_route_method (#952)
@@ -77,6 +78,14 @@ static const char *strip_quotes(CBMArena *a, const char *text) {
return text;
}
+/* A constant reference in a folding language (#706, #1147): when it does not
+ * fold to a usable value it stays unresolved -- the raw map entry may hold an
+ * unresolved "{}" base and is never a URL on its own. */
+static bool is_folded_reference(const CBMExtractCtx *ctx, const char *kind) {
+ return cbm_url_fold_lang(ctx->language) &&
+ (strcmp(kind, "identifier") == 0 || strcmp(kind, "member_expression") == 0);
+}
+
// Callee suffixes for IRIS Python interop string-dispatch. Kept at file scope
// (not inside the function) to satisfy cppcheck variableScope.
static const char *s_py_dispatch_suffixes[] = {".classMethodValue", ".classMethodVoid",
@@ -2428,6 +2437,30 @@ static const char *python_iris_cls_callee(CBMExtractCtx *ctx, TSNode call_node)
// --- Unified handler: called once per node by the cursor walk ---
+/* Topic slots carry their literal identity even when a URL projection exists. */
+static bool is_topic_keyword(const char *key) {
+ static const char *keywords[] = {"topic", "topic_id", "topic_name", "queue", "queue_name",
+ "queue_id", "subject", "channel", NULL};
+ for (int i = 0; key && keywords[i]; i++) {
+ if (strcmp(key, keywords[i]) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* Generic argument values stay raw. Only URL consumers may select the separate
+ * projection, and explicit topic slots never carry one. */
+static void fold_call_arg(CBMExtractCtx *ctx, TSNode node, CBMCallArg *ca) {
+ ca->value = cbm_url_fold_exact(ctx, node);
+ if (!is_topic_keyword(ca->keyword)) {
+ const char *url = cbm_url_fold_call_url(ctx, node);
+ if (url && (!ca->value || strcmp(url, ca->value) != 0)) {
+ ca->url_value = url;
+ }
+ }
+}
+
// Process a keyword argument (keyword_argument or pair node).
static void process_keyword_arg(CBMExtractCtx *ctx, TSNode arg_node, CBMCallArg *ca) {
TSNode key_n = ts_node_child_by_field_name(arg_node, TS_FIELD("name"));
@@ -2440,6 +2473,11 @@ static void process_keyword_arg(CBMExtractCtx *ctx, TSNode arg_node, CBMCallArg
}
if (!ts_node_is_null(val_n)) {
ca->expr = cbm_node_text(ctx->arena, val_n, ctx->source);
+ /* Only a fully resolved fold is an exact value (#706, #1147). */
+ fold_call_arg(ctx, val_n, ca);
+ if (ca->value || is_folded_reference(ctx, ts_node_type(val_n))) {
+ return;
+ }
if (strcmp(ts_node_type(val_n), "identifier") == 0 && ca->expr) {
ca->value = lookup_string_constant(ctx, ca->expr);
} else if (is_string_like(ts_node_type(val_n)) && ca->expr) {
@@ -2448,7 +2486,7 @@ static void process_keyword_arg(CBMExtractCtx *ctx, TSNode arg_node, CBMCallArg
}
}
-static const char *extract_string_value(CBMExtractCtx *ctx, TSNode val_node);
+static const char *extract_string_value(CBMExtractCtx *ctx, TSNode val_node, bool url_context);
/* A JS/TS request-config object -- `http({url: `/users/${id}`, method: 'GET'})`,
* `axios({url: '/orders'})`, the shape Orval and similar generators emit -- names
@@ -2474,7 +2512,8 @@ static bool config_object_callee_eligible(const CBMExtractCtx *ctx, const char *
return !(clen >= glen && strcmp(callee_name + clen - glen, get_uri) == 0);
}
-static const char *js_config_object_url(CBMExtractCtx *ctx, TSNode obj, const char *callee_name) {
+static const char *js_config_object_url(CBMExtractCtx *ctx, TSNode obj, const char *callee_name,
+ bool url_context) {
if (strcmp(ts_node_type(obj), "object") != 0 ||
!config_object_callee_eligible(ctx, callee_name)) {
return NULL;
@@ -2492,7 +2531,7 @@ static const char *js_config_object_url(CBMExtractCtx *ctx, TSNode obj, const ch
}
const char *key = strip_quotes(ctx->arena, cbm_node_text(ctx->arena, key_n, ctx->source));
if (key && strcmp(key, "url") == 0) {
- return extract_string_value(ctx, val_n);
+ return extract_string_value(ctx, val_n, url_context);
}
}
return NULL;
@@ -2532,6 +2571,14 @@ static void extract_call_args(CBMExtractCtx *ctx, TSNode args, CBMCall *call) {
} else {
ca->expr = cbm_node_text(ctx->arena, arg_node, ctx->source);
ca->index = positional_idx++;
+ /* Python / JS / TS: a URL composed from module constants carries its
+ * folded value, but only when nothing leading stayed unresolved
+ * (#706, #1147); otherwise the long-standing handling below. */
+ fold_call_arg(ctx, arg_node, ca);
+ if (ca->value || is_folded_reference(ctx, ak)) {
+ call->arg_count++;
+ continue;
+ }
if (is_string_like(ak) && ca->expr) {
ca->value = strip_quotes(ctx->arena, ca->expr);
} else if (strcmp(ak, "template_string") == 0) {
@@ -2543,7 +2590,11 @@ static void extract_call_args(CBMExtractCtx *ctx, TSNode args, CBMCall *call) {
} else if (strcmp(ak, "object") == 0) {
/* Request-config object: its `url` is what the arg-url
* heuristic reads for a local fetch wrapper (#2235). */
- ca->value = js_config_object_url(ctx, arg_node, call->callee_name);
+ ca->value = js_config_object_url(ctx, arg_node, call->callee_name, false);
+ const char *url = js_config_object_url(ctx, arg_node, call->callee_name, true);
+ if (url && (!ca->value || strcmp(url, ca->value) != 0)) {
+ ca->url_value = url;
+ }
} else if (strcmp(ak, "call_expression") == 0) {
/* URL-builder helper call (issue #1009): resolve
* client(buildPath(id)) through the per-file builder map. */
@@ -2564,20 +2615,12 @@ static void extract_call_args(CBMExtractCtx *ctx, TSNode args, CBMCall *call) {
static bool is_url_or_topic_keyword(const char *key) {
static const char *url_keywords[] = {"url", "endpoint", "path", "uri",
"target_url", "base_url", NULL};
- static const char *topic_keywords[] = {"topic", "topic_id", "topic_name",
- "queue", "queue_name", "queue_id",
- "subject", "channel", NULL};
for (int i = 0; url_keywords[i]; i++) {
if (strcmp(key, url_keywords[i]) == 0) {
return true;
}
}
- for (int i = 0; topic_keywords[i]; i++) {
- if (strcmp(key, topic_keywords[i]) == 0) {
- return true;
- }
- }
- return false;
+ return is_topic_keyword(key);
}
// Check if a struct-field name identifies a queue/topic target. Cloud SDKs pass
@@ -2599,8 +2642,13 @@ static bool is_queue_topic_field(const char *key) {
}
// Extract string value from a node (literal or constant reference).
-static const char *extract_string_value(CBMExtractCtx *ctx, TSNode val_node) {
+static const char *extract_string_value(CBMExtractCtx *ctx, TSNode val_node, bool url_context) {
const char *vk = ts_node_type(val_node);
+ const char *folded =
+ url_context ? cbm_url_fold_call_url(ctx, val_node) : cbm_url_fold_call_raw(ctx, val_node);
+ if (folded || is_folded_reference(ctx, vk)) {
+ return folded;
+ }
if (strcmp(vk, "template_string") == 0) {
return cbm_template_string_text(ctx->arena, val_node, ctx->source);
}
@@ -2671,7 +2719,7 @@ static const char *extract_composite_queue_field(CBMExtractCtx *ctx, TSNode node
if (!is_queue_topic_field(key)) {
continue;
}
- const char *resolved = extract_string_value(ctx, val_n);
+ const char *resolved = extract_string_value(ctx, val_n, false);
if (resolved && resolved[0]) {
return resolved;
}
@@ -2686,7 +2734,7 @@ static const char *extract_composite_queue_field(CBMExtractCtx *ctx, TSNode node
}
// Try to extract URL/topic from a keyword_argument or pair node.
-static const char *extract_keyword_url(CBMExtractCtx *ctx, TSNode arg) {
+static const char *extract_keyword_url(CBMExtractCtx *ctx, TSNode arg, const char *callee_name) {
TSNode key_node = ts_node_child_by_field_name(arg, TS_FIELD("name"));
TSNode val_node = ts_node_child_by_field_name(arg, TS_FIELD("value"));
if (ts_node_is_null(key_node)) {
@@ -2699,7 +2747,10 @@ static const char *extract_keyword_url(CBMExtractCtx *ctx, TSNode arg) {
if (!key || !is_url_or_topic_keyword(key)) {
return NULL;
}
- return extract_string_value(ctx, val_node);
+ bool url_context =
+ !is_topic_keyword(key) && (cbm_service_pattern_match(callee_name) == CBM_SVC_HTTP ||
+ cbm_service_pattern_is_global_fetch(callee_name));
+ return extract_string_value(ctx, val_node, url_context);
}
// `prefixVar + "/route"` (Go's idiomatic configurable-base-path pattern):
@@ -2776,12 +2827,43 @@ static TSNode swift_unwrap_url_constructor(CBMExtractCtx *ctx, TSNode arg) {
return swift_argument_value(ts_node_named_child(inner, 0));
}
-static const char *extract_positional_url(CBMExtractCtx *ctx, TSNode arg, const char *ak) {
+/* `${BASE}/route` -- the JS/TS twin of #1249's `base + "/route"`. A template
+ * that opens with one substitution and continues with a literal path is a
+ * configurable base URL (`${process.env.BACKEND_URL}/wallet`), so the route is
+ * the literal path after it. Anything else (`${a}${b}`, `${BASE}/`, a template
+ * that opens with text) comes back unchanged: no path is fabricated (#2291). */
+static const char *template_path_after_base(TSNode tpl, const char *flat) {
+ if (ts_node_named_child_count(tpl) < PAIR_LEN ||
+ strcmp(ts_node_type(ts_node_named_child(tpl, 0)), "template_substitution") != 0) {
+ return flat;
+ }
+ const char *path = flat + PAIR_LEN; /* past the base's "{}" placeholder */
+ /* `${base}/${tail}` has no literal path to recover: "/{}" is not a route. */
+ return (path[0] == '/' && cbm_url_has_literal_path(path)) ? path : flat;
+}
+
+static const char *extract_positional_url(CBMExtractCtx *ctx, TSNode arg, const char *ak,
+ bool url_context) {
+ /* Python / JS / TS: fold a URL composed from module constants (#706,
+ * #1147). A reference that folds to nothing usable stays unresolved; a
+ * template or concatenation falls back to the #1006 / #1249 / #2291
+ * handling below. */
+ const char *folded =
+ url_context ? cbm_url_fold_call_url(ctx, arg) : cbm_url_fold_call_raw(ctx, arg);
+ if (folded) {
+ return strip_and_validate_string_arg(ctx->arena, (char *)folded);
+ }
+ if (is_folded_reference(ctx, ak)) {
+ return NULL;
+ }
/* JS/TS template literals: `/things/${id}` normalizes to "/things/{}" so the
* client URL joins the server route's canonical placeholder (issue #1006). */
if (strcmp(ak, "template_string") == 0) {
const char *flat = cbm_template_string_text(ctx->arena, arg, ctx->source);
if (flat) {
+ if (url_context) {
+ flat = template_path_after_base(arg, flat);
+ }
return strip_and_validate_string_arg(ctx->arena, (char *)flat);
}
}
@@ -2830,7 +2912,7 @@ static const char *extract_url_or_topic_arg(CBMExtractCtx *ctx, TSNode args,
const char *ak = ts_node_type(arg);
if (strcmp(ak, "keyword_argument") == 0 || strcmp(ak, "pair") == 0) {
- const char *val = extract_keyword_url(ctx, arg);
+ const char *val = extract_keyword_url(ctx, arg, callee_name);
if (val) {
return val;
}
@@ -2839,7 +2921,9 @@ static const char *extract_url_or_topic_arg(CBMExtractCtx *ctx, TSNode args,
/* JS/TS request-config object: `axios({url: '/orders'})` (#2235). */
if (strcmp(ak, "object") == 0) {
- const char *val = js_config_object_url(ctx, arg, callee_name);
+ bool url_context = cbm_service_pattern_match(callee_name) == CBM_SVC_HTTP ||
+ cbm_service_pattern_is_global_fetch(callee_name);
+ const char *val = js_config_object_url(ctx, arg, callee_name, url_context);
if (val) {
return val;
}
@@ -2870,7 +2954,11 @@ static const char *extract_url_or_topic_arg(CBMExtractCtx *ctx, TSNode args,
}
if (ai < MAX_POSITIONAL_SCAN) {
- const char *val = extract_positional_url(ctx, arg, ak);
+ /* Unknown/aliased callees keep raw text until service resolution.
+ * Relative HTTP candidates remain available in args[].url_value. */
+ bool url_context = cbm_service_pattern_match(callee_name) == CBM_SVC_HTTP ||
+ cbm_service_pattern_is_global_fetch(callee_name);
+ const char *val = extract_positional_url(ctx, arg, ak, url_context);
if (val) {
return val;
}
diff --git a/internal/cbm/extract_unified.c b/internal/cbm/extract_unified.c
index 4e83ca900..f0590de5f 100644
--- a/internal/cbm/extract_unified.c
+++ b/internal/cbm/extract_unified.c
@@ -2,8 +2,9 @@
#include "arena.h" // cbm_arena_sprintf
#include "cbm.h" // CBMExtractCtx
#include "helpers.h"
-#include "lang_specs.h" // CBMLangSpec, cbm_lang_spec, CBM_LANG_*
-#include "tree_sitter/api.h" // TSNode, TSTreeCursor, ts_tree_cursor_*, ts_node_*
+#include "extract_url_fold.h" // cbm_url_fold_record_constant (#706, #1147)
+#include "lang_specs.h" // CBMLangSpec, cbm_lang_spec, CBM_LANG_*
+#include "tree_sitter/api.h" // TSNode, TSTreeCursor, ts_tree_cursor_*, ts_node_*
#include "foundation/constants.h"
#include "foundation/compat.h" // cbm_thread_cpu_time_ns
#include <stdlib.h>
@@ -1219,6 +1220,14 @@ static void handle_string_constants(CBMExtractCtx *ctx, TSNode node, const WalkS
return;
}
+ /* Python and JS/TS fold the value: `BASE + "/path"`, `${BASE}/path`,
+ * f"{BASE}/path" and object-literal endpoint maps (#706, #1147). */
+ if (cbm_url_fold_lang(ctx->language)) {
+ cbm_url_fold_record_constant(ctx, cbm_node_text(ctx->arena, name_node, ctx->source),
+ value_node);
+ return;
+ }
+
/* Value must be a string literal (template literals flatten to "{}" form) */
const char *value_kind = ts_node_type(value_node);
const char *flat_value = NULL;
diff --git a/internal/cbm/extract_url_fold.c b/internal/cbm/extract_url_fold.c
new file mode 100644
index 000000000..63f8b4bb5
--- /dev/null
+++ b/internal/cbm/extract_url_fold.c
@@ -0,0 +1,451 @@
+/* URL constant folding for HTTP client calls (issues #706, #1147).
+ * See extract_url_fold.h for the contract. */
+#include "extract_url_fold.h"
+#include "arena.h" // cbm_arena_strndup, cbm_arena_sprintf
+#include "helpers.h"
+#include "foundation/constants.h"
+#include <ctype.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <string.h>
+
+/* FOLD_BUF matches the template flattener's limit; FOLD_MAX_DEPTH bounds the
+ * recursion of nested `a + b + c` chains and templates; object-literal endpoint
+ * maps are followed at most FOLD_MAX_OBJ_DEPTH levels deep. */
+enum { FOLD_BUF = 512, FOLD_MAX_DEPTH = 16, FOLD_MAX_OBJ_DEPTH = 4, FOLD_NAME_BUF = 256 };
+
+static const char k_unknown[] = "{}";
+
+bool cbm_url_fold_lang(CBMLanguage lang) {
+ return lang == CBM_LANG_PYTHON || lang == CBM_LANG_JAVASCRIPT || lang == CBM_LANG_TYPESCRIPT ||
+ lang == CBM_LANG_TSX;
+}
+
+static bool at_placeholder(const char *s) {
+ return s[0] == '{' && s[SKIP_ONE] == '}';
+}
+
+bool cbm_url_has_literal_path(const char *url) {
+ if (!url) {
+ return false;
+ }
+ const char *p = url;
+ while (*p) {
+ if (at_placeholder(p)) {
+ p += PAIR_LEN;
+ } else if (*p == '/') {
+ p++;
+ } else {
+ return true;
+ }
+ }
+ return false;
+}
+
+/* Any text at all besides "{}" placeholders ("/" counts: a root constant). */
+static bool has_literal_text(const char *s) {
+ const char *p = s;
+ while (*p) {
+ if (!at_placeholder(p)) {
+ return true;
+ }
+ p += PAIR_LEN;
+ }
+ return false;
+}
+
+/* "some/path", "api/users/{}": a relative URL path of at least two segments.
+ * Only such a value is read as a path under a base URL. */
+static bool relative_path_shaped(const char *s) {
+ if (!isalnum((unsigned char)s[0]) && s[0] != '_') {
+ return false;
+ }
+ bool slash = false;
+ bool segment_after_slash = false;
+ for (const char *p = s; *p; p++) {
+ unsigned char c = (unsigned char)*p;
+ if (c == '/') {
+ if (p[SKIP_ONE] == '/') {
+ return false;
+ }
+ slash = true;
+ continue;
+ }
+ if (!isalnum(c) && !strchr("-_.~%{}", c)) {
+ return false;
+ }
+ segment_after_slash = segment_after_slash || slash;
+ }
+ return slash && segment_after_slash;
+}
+
+static const char *lookup_constant(const CBMExtractCtx *ctx, const char *name, bool url) {
+ const CBMStringConstantMap *map = &ctx->string_constants;
+ for (int i = 0; i < map->count; i++) {
+ if (!map->is_url_builder[i] && map->values[i] && strcmp(map->names[i], name) == 0) {
+ return url && map->url_values[i] ? map->url_values[i] : map->values[i];
+ }
+ }
+ return NULL;
+}
+
+static void push_constant(CBMExtractCtx *ctx, const char *name, const char *value,
+ const char *url_value) {
+ CBMStringConstantMap *map = &ctx->string_constants;
+ if (!name || !value || map->count >= CBM_MAX_STRING_CONSTANTS) {
+ return;
+ }
+ map->names[map->count] = name;
+ map->values[map->count] = value;
+ map->url_values[map->count] = url_value;
+ map->is_url_builder[map->count] = false;
+ map->count++;
+}
+
+/* --- folding --------------------------------------------------------- */
+
+typedef struct {
+ char text[FOLD_BUF];
+ size_t len;
+ bool overflow;
+ bool url; /* URL projection; false preserves raw topic/string identity */
+ bool base_ref; /* the first part is a resolved constant reference */
+ bool has_parts; /* at least one part appended */
+} fold_buf_t;
+
+static const char *fold_node(CBMExtractCtx *ctx, TSNode node, int depth, bool url);
+
+static void buf_append(fold_buf_t *b, const char *piece) {
+ /* Only URL projections collapse the boundary between a base ending in '/'
+ * and a path starting with '/'. Raw strings/topics retain both separators
+ * ("tenant/" + "/events" is "tenant//events"). Avoid doubling a separator ("{}/" + "/api/x"); a
+ * scheme's "://" is kept. */
+ if (b->url && b->len > 0 && b->text[b->len - SKIP_ONE] == '/' && piece[0] == '/' &&
+ !(b->len >= PAIR_LEN && b->text[b->len - PAIR_LEN] == ':')) {
+ piece++;
+ }
+ size_t pl = strlen(piece);
+ if (b->len + pl >= FOLD_BUF) {
+ b->overflow = true;
+ return;
+ }
+ memcpy(b->text + b->len, piece, pl);
+ b->len += pl;
+ b->text[b->len] = '\0';
+}
+
+static bool is_reference_kind(const char *k) {
+ return strcmp(k, "identifier") == 0 || strcmp(k, "member_expression") == 0 ||
+ strcmp(k, "template_substitution") == 0 || strcmp(k, "interpolation") == 0;
+}
+
+/* Append one part of a composition. The value of a template substitution or
+ * f-string interpolation is its inner expression. */
+static void fold_part(CBMExtractCtx *ctx, fold_buf_t *b, TSNode part, int depth) {
+ const char *k = ts_node_type(part);
+ TSNode expr = part;
+ if (strcmp(k, "template_substitution") == 0) {
+ expr = ts_node_named_child(part, 0);
+ } else if (strcmp(k, "interpolation") == 0) {
+ expr = ts_node_child_by_field_name(part, TS_FIELD("expression"));
+ }
+ const char *v = ts_node_is_null(expr) ? NULL : fold_node(ctx, expr, depth + SKIP_ONE, b->url);
+ if (!b->has_parts) {
+ b->base_ref = v && is_reference_kind(k) && !at_placeholder(v);
+ }
+ b->has_parts = true;
+ buf_append(b, v ? v : k_unknown);
+}
+
+static void fold_literal_piece(CBMExtractCtx *ctx, fold_buf_t *b, TSNode piece) {
+ const char *t = cbm_node_text(ctx->arena, piece, ctx->source);
+ b->has_parts = true;
+ buf_append(b, t ? t : "");
+}
+
+/* In URL projections, a resolved first constant is `BASE + path`: a
+ * relative BASE ('api') joined to a path is a path under the client's base
+ * URL, so it is read from the root ("/api/users/me"). */
+static const char *finish(CBMExtractCtx *ctx, const fold_buf_t *b) {
+ if (b->overflow) {
+ return NULL;
+ }
+ if (b->url && b->base_ref && b->text[0] != '/' && !strstr(b->text, "://") &&
+ relative_path_shaped(b->text)) {
+ return cbm_arena_sprintf(ctx->arena, "/%s", b->text);
+ }
+ return cbm_arena_strndup(ctx->arena, b->text, b->len);
+}
+
+/* JS/TS `string`, Python `string` (also f-strings), JS `template_string`. */
+static const char *fold_string_like(CBMExtractCtx *ctx, TSNode node, int depth, bool url) {
+ fold_buf_t b = {.len = 0, .url = url};
+ b.text[0] = '\0';
+ uint32_t nc = ts_node_named_child_count(node);
+ for (uint32_t i = 0; i < nc; i++) {
+ TSNode c = ts_node_named_child(node, i);
+ const char *k = ts_node_type(c);
+ if (strcmp(k, "template_substitution") == 0 || strcmp(k, "interpolation") == 0) {
+ fold_part(ctx, &b, c, depth);
+ } else if (strcmp(k, "string_fragment") == 0 || strcmp(k, "string_content") == 0 ||
+ strcmp(k, "escape_sequence") == 0) {
+ fold_literal_piece(ctx, &b, c);
+ } else if (strcmp(k, "escape_interpolation") == 0) {
+ b.has_parts = true;
+ buf_append(&b, "{"); /* `{{` in an f-string is one literal brace */
+ }
+ }
+ return finish(ctx, &b);
+}
+
+static bool is_plus(CBMExtractCtx *ctx, TSNode bin) {
+ TSNode op = ts_node_child_by_field_name(bin, TS_FIELD("operator"));
+ if (ts_node_is_null(op)) {
+ return false;
+ }
+ const char *t = cbm_node_text(ctx->arena, op, ctx->source);
+ return t && strcmp(t, "+") == 0;
+}
+
+/* `a + b` (JS binary_expression / Python binary_operator). */
+static const char *fold_concat(CBMExtractCtx *ctx, TSNode node, int depth, bool url) {
+ if (!is_plus(ctx, node)) {
+ return NULL;
+ }
+ TSNode left = ts_node_child_by_field_name(node, TS_FIELD("left"));
+ TSNode right = ts_node_child_by_field_name(node, TS_FIELD("right"));
+ if (ts_node_is_null(left) || ts_node_is_null(right)) {
+ return NULL;
+ }
+ fold_buf_t b = {.len = 0, .url = url};
+ b.text[0] = '\0';
+ fold_part(ctx, &b, left, depth);
+ fold_part(ctx, &b, right, depth);
+ return finish(ctx, &b);
+}
+
+/* Python implicit concatenation: "a" "b". */
+static const char *fold_implicit_concat(CBMExtractCtx *ctx, TSNode node, int depth, bool url) {
+ fold_buf_t b = {.len = 0, .url = url};
+ b.text[0] = '\0';
+ uint32_t nc = ts_node_named_child_count(node);
+ for (uint32_t i = 0; i < nc; i++) {
+ fold_part(ctx, &b, ts_node_named_child(node, i), depth);
+ }
+ return finish(ctx, &b);
+}
+
+/* "A.B.C" for a JS member chain over identifiers, or false. */
+static bool dotted_name(CBMExtractCtx *ctx, TSNode node, char *out, size_t cap, int depth) {
+ const char *k = ts_node_type(node);
+ if (strcmp(k, "identifier") == 0) {
+ const char *t = cbm_node_text(ctx->arena, node, ctx->source);
+ return t && snprintf(out, cap, "%s", t) < (int)cap;
+ }
+ if (strcmp(k, "member_expression") != 0 || depth >= FOLD_MAX_OBJ_DEPTH) {
+ return false;
+ }
+ TSNode obj = ts_node_child_by_field_name(node, TS_FIELD("object"));
+ TSNode prop = ts_node_child_by_field_name(node, TS_FIELD("property"));
+ if (ts_node_is_null(obj) || ts_node_is_null(prop) ||
+ strcmp(ts_node_type(prop), "property_identifier") != 0 ||
+ !dotted_name(ctx, obj, out, cap, depth + SKIP_ONE)) {
+ return false;
+ }
+ const char *p = cbm_node_text(ctx->arena, prop, ctx->source);
+ size_t used = strlen(out);
+ return p && snprintf(out + used, cap - used, ".%s", p) < (int)(cap - used);
+}
+
+static const char *fold_reference(CBMExtractCtx *ctx, TSNode node, bool url) {
+ char name[FOLD_NAME_BUF];
+ if (!dotted_name(ctx, node, name, sizeof(name), 0)) {
+ return NULL;
+ }
+ return lookup_constant(ctx, name, url);
+}
+
+/* Type-only wrappers and grouping: `x as const`, `x satisfies T`, `x!`, `(x)`. */
+static bool is_transparent_wrapper(const char *k) {
+ return strcmp(k, "parenthesized_expression") == 0 || strcmp(k, "as_expression") == 0 ||
+ strcmp(k, "satisfies_expression") == 0 || strcmp(k, "non_null_expression") == 0;
+}
+
+static const char *fold_node(CBMExtractCtx *ctx, TSNode node, int depth, bool url) {
+ if (depth > FOLD_MAX_DEPTH || ts_node_is_null(node)) {
+ return NULL;
+ }
+ const char *k = ts_node_type(node);
+ if (strcmp(k, "string") == 0 || strcmp(k, "template_string") == 0) {
+ return fold_string_like(ctx, node, depth, url);
+ }
+ if (strcmp(k, "identifier") == 0 || strcmp(k, "member_expression") == 0) {
+ return fold_reference(ctx, node, url);
+ }
+ if (strcmp(k, "binary_expression") == 0 || strcmp(k, "binary_operator") == 0) {
+ return fold_concat(ctx, node, depth, url);
+ }
+ if (strcmp(k, "concatenated_string") == 0) {
+ return fold_implicit_concat(ctx, node, depth, url);
+ }
+ if (is_transparent_wrapper(k) && ts_node_named_child_count(node) > 0) {
+ return fold_node(ctx, ts_node_named_child(node, 0), depth + SKIP_ONE, url);
+ }
+ return NULL;
+}
+
+/* --- constants ------------------------------------------------------- */
+
+/* Strip type wrappers and `Object.freeze(...)` from a constant's value. */
+static TSNode unwrap_value(CBMExtractCtx *ctx, TSNode v) {
+ for (int i = 0; i < FOLD_MAX_OBJ_DEPTH && !ts_node_is_null(v); i++) {
+ const char *k = ts_node_type(v);
+ if (is_transparent_wrapper(k) && ts_node_named_child_count(v) > 0) {
+ v = ts_node_named_child(v, 0);
+ continue;
+ }
+ if (strcmp(k, "call_expression") != 0) {
+ break;
+ }
+ TSNode fn = ts_node_child_by_field_name(v, TS_FIELD("function"));
+ TSNode args = ts_node_child_by_field_name(v, TS_FIELD("arguments"));
+ const char *ft = ts_node_is_null(fn) ? NULL : cbm_node_text(ctx->arena, fn, ctx->source);
+ if (!ft || strcmp(ft, "Object.freeze") != 0 || ts_node_is_null(args) ||
+ ts_node_named_child_count(args) != SKIP_ONE) {
+ break;
+ }
+ v = ts_node_named_child(args, 0);
+ }
+ return v;
+}
+
+static void record_value(CBMExtractCtx *ctx, const char *name, TSNode value, int depth);
+
+/* The key of an object-literal pair as a plain name, or NULL. */
+static const char *pair_key(CBMExtractCtx *ctx, TSNode pair) {
+ TSNode key = ts_node_child_by_field_name(pair, TS_FIELD("key"));
+ if (ts_node_is_null(key)) {
+ return NULL;
+ }
+ const char *k = ts_node_type(key);
+ if (strcmp(k, "property_identifier") == 0) {
+ return cbm_node_text(ctx->arena, key, ctx->source);
+ }
+ if (strcmp(k, "string") == 0) {
+ return fold_string_like(ctx, key, 0, false);
+ }
+ return NULL;
+}
+
+static void record_object(CBMExtractCtx *ctx, const char *prefix, TSNode obj, int depth) {
+ uint32_t nc = ts_node_named_child_count(obj);
+ for (uint32_t i = 0; i < nc; i++) {
+ TSNode member = ts_node_named_child(obj, i);
+ const char *k = ts_node_type(member);
+ if (strcmp(k, "pair") == 0) {
+ const char *key = pair_key(ctx, member);
+ TSNode value = ts_node_child_by_field_name(member, TS_FIELD("value"));
+ if (key && key[0] && !ts_node_is_null(value)) {
+ record_value(ctx, cbm_arena_sprintf(ctx->arena, "%s.%s", prefix, key), value,
+ depth + SKIP_ONE);
+ }
+ } else if (strcmp(k, "shorthand_property_identifier") == 0) {
+ /* `{ BASE }` carries the constant of the same name. */
+ const char *key = cbm_node_text(ctx->arena, member, ctx->source);
+ const char *v = key ? lookup_constant(ctx, key, false) : NULL;
+ if (v) {
+ push_constant(ctx, cbm_arena_sprintf(ctx->arena, "%s.%s", prefix, key), v,
+ lookup_constant(ctx, key, true));
+ }
+ }
+ }
+}
+
+static void record_value(CBMExtractCtx *ctx, const char *name, TSNode value, int depth) {
+ if (!name || depth > FOLD_MAX_OBJ_DEPTH) {
+ return;
+ }
+ value = unwrap_value(ctx, value);
+ if (ts_node_is_null(value)) {
+ return;
+ }
+ if (strcmp(ts_node_type(value), "object") == 0) {
+ record_object(ctx, name, value, depth);
+ return;
+ }
+ const char *v = fold_node(ctx, value, 0, false);
+ if (v && has_literal_text(v)) {
+ push_constant(ctx, name, v, fold_node(ctx, value, 0, true));
+ }
+}
+
+void cbm_url_fold_record_constant(CBMExtractCtx *ctx, const char *name, TSNode value) {
+ if (!name || !name[0] || ts_node_is_null(value)) {
+ return;
+ }
+ record_value(ctx, name, value, 0);
+}
+
+/* --- call sites ------------------------------------------------------ */
+
+/* Python strings fold only when they interpolate (an f-string); a plain
+ * literal keeps the long-standing literal path. */
+static bool is_interpolated_string(TSNode node) {
+ uint32_t nc = ts_node_named_child_count(node);
+ for (uint32_t i = 0; i < nc; i++) {
+ if (strcmp(ts_node_type(ts_node_named_child(node, i)), "interpolation") == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool is_foldable_arg(TSNode arg) {
+ const char *k = ts_node_type(arg);
+ if (strcmp(k, "string") == 0) {
+ return is_interpolated_string(arg);
+ }
+ return strcmp(k, "template_string") == 0 || strcmp(k, "binary_expression") == 0 ||
+ strcmp(k, "binary_operator") == 0 || strcmp(k, "identifier") == 0 ||
+ strcmp(k, "member_expression") == 0 || strcmp(k, "concatenated_string") == 0 ||
+ is_transparent_wrapper(k);
+}
+
+const char *cbm_url_fold_call_url(CBMExtractCtx *ctx, TSNode arg) {
+ if (!cbm_url_fold_lang(ctx->language) || ts_node_is_null(arg) || !is_foldable_arg(arg)) {
+ return NULL;
+ }
+ const char *s = fold_node(ctx, arg, 0, true);
+ if (!s) {
+ return NULL;
+ }
+ if (!at_placeholder(s)) {
+ return has_literal_text(s) ? s : NULL;
+ }
+ /* Unresolvable base: keep the literal path after it, never the base. */
+ const char *rest = s + PAIR_LEN;
+ if (rest[0] == '/') {
+ return cbm_url_has_literal_path(rest) ? rest : NULL;
+ }
+ if (relative_path_shaped(rest)) {
+ return cbm_arena_sprintf(ctx->arena, "/%s", rest);
+ }
+ return NULL;
+}
+
+const char *cbm_url_fold_exact(CBMExtractCtx *ctx, TSNode arg) {
+ if (!cbm_url_fold_lang(ctx->language) || ts_node_is_null(arg) || !is_foldable_arg(arg)) {
+ return NULL;
+ }
+ const char *s = fold_node(ctx, arg, 0, false);
+ return (s && !at_placeholder(s) && has_literal_text(s)) ? s : NULL;
+}
+
+const char *cbm_url_fold_call_raw(CBMExtractCtx *ctx, TSNode arg) {
+ if (!cbm_url_fold_lang(ctx->language) || ts_node_is_null(arg) || !is_foldable_arg(arg)) {
+ return NULL;
+ }
+ const char *s = fold_node(ctx, arg, 0, false);
+ return s && has_literal_text(s) ? s : NULL;
+}
diff --git a/internal/cbm/extract_url_fold.h b/internal/cbm/extract_url_fold.h
new file mode 100644
index 000000000..6dae8bd52
--- /dev/null
+++ b/internal/cbm/extract_url_fold.h
@@ -0,0 +1,45 @@
+#ifndef CBM_EXTRACT_URL_FOLD_H
+#define CBM_EXTRACT_URL_FOLD_H
+
+/* URL constant folding for HTTP client calls (issues #706, #1147).
+ *
+ * A caller that centralises its endpoints writes the URL as an expression over
+ * module constants -- `API_URL = API_BASE_URL + "some/path"` in Python,
+ * `${BASE}/games/launch` or `API_ENDPOINTS.USER` in JS/TS. These helpers fold
+ * such an expression into one string: string literals and module-level string
+ * constants (including members of an object-literal constant) inline, and a
+ * part that cannot be resolved becomes the canonical "{}" placeholder. Python
+ * and the JS/TS family only. */
+
+#include "cbm.h"
+#include "tree_sitter/api.h"
+
+/* True for the languages whose expressions are folded. */
+bool cbm_url_fold_lang(CBMLanguage lang);
+
+/* True when a URL carries something literal besides '/' and "{}"
+ * placeholders, i.e. a real path to recover rather than only unknowns. */
+bool cbm_url_has_literal_path(const char *url);
+
+/* Record a module-level `name = value` in the per-file string constant map
+ * with separate raw and URL-projected values. An object-literal value records each string-valued
+ * member as "name.KEY" (nested objects as "name.A.B"). */
+void cbm_url_fold_record_constant(CBMExtractCtx *ctx, const char *name, TSNode value);
+
+/* The URL a client call receives through `arg`, or NULL when the argument is
+ * not a foldable expression or holds nothing literal. A base that cannot be
+ * resolved is dropped and the literal path after it kept ("{}/foo" -> "/foo",
+ * "{}some/path" -> "/some/path"), exactly like #1249 / #2291: the path is
+ * partial, never presented with an invented base. */
+const char *cbm_url_fold_call_url(CBMExtractCtx *ctx, TSNode arg);
+
+/* The raw fold, including unresolved placeholders. Never changes separators
+ * or removes a leading unknown component; suitable for topics and generic calls. */
+const char *cbm_url_fold_call_raw(CBMExtractCtx *ctx, TSNode arg);
+
+/* The raw resolved value of a foldable, non-literal argument, or NULL when
+ * any leading part stayed unresolved. For slots that must hold an exact
+ * value (CBMCallArg.value). */
+const char *cbm_url_fold_exact(CBMExtractCtx *ctx, TSNode arg);
+
+#endif /* CBM_EXTRACT_URL_FOLD_H */
diff --git a/internal/cbm/result_compact.c b/internal/cbm/result_compact.c
index b9e4d2be6..cb77ead58 100644
--- a/internal/cbm/result_compact.c
+++ b/internal/cbm/result_compact.c
@@ -294,6 +294,7 @@ static void cr_walk_call(cr_ctx_t *c, CBMCall *call) {
for (int i = 0; i < argc && call->args; i++) {
cr_str(c, &call->args[i].expr);
cr_str(c, &call->args[i].value);
+ cr_str(c, &call->args[i].url_value);
cr_str(c, &call->args[i].keyword);
}
} else if (c->phase == CR_COPY) {
diff --git a/src/pipeline/pass_parallel.c b/src/pipeline/pass_parallel.c
index 8cdfb80e8..7144a8963 100644
--- a/src/pipeline/pass_parallel.c
+++ b/src/pipeline/pass_parallel.c
@@ -2461,19 +2461,38 @@ static bool normalize_url_arg(const char *url, char *norm, int norm_sz) {
return !is_junk_url(norm);
}
+static bool arg_is_topic(const CBMCallArg *arg) {
+ static const char *keywords[] = {"topic", "topic_id", "topic_name", "queue", "queue_name",
+ "queue_id", "subject", "channel", NULL};
+ for (int i = 0; arg->keyword && keywords[i]; i++) {
+ if (strcmp(arg->keyword, keywords[i]) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
/* Detect API paths in call arguments and create HTTP_CALLS edges. */
-static void detect_url_in_args(cbm_gbuf_t *gbuf, const cbm_gbuf_node_t *source,
- const CBMCall *call) {
+static void detect_url_in_args(cbm_gbuf_t *gbuf, const cbm_gbuf_node_t *source, const CBMCall *call,
+ cbm_svc_kind_t svc) {
+ /* A resolved alias may be ASYNC even when its source spelling is unknown.
+ * Neither raw slash topics nor URL projections are HTTP evidence there. */
+ if (svc == CBM_SVC_ASYNC || cbm_service_pattern_match(call->callee_name) == CBM_SVC_ASYNC) {
+ return;
+ }
for (int ai = 0; ai < call->arg_count; ai++) {
const CBMCallArg *ca = &call->args[ai];
+ if (arg_is_topic(ca)) {
+ continue;
+ }
/* A slash-prefixed raw expression is not a URL string. In JS/TS this
* is notably a regex literal (`/<table/i`); genuine string literals
* and propagated constants are carried in `value`, while template
* literals keep their leading backtick in `expr`. */
- if (!ca->value && ca->expr && ca->expr[0] == '/') {
+ if (!ca->value && !ca->url_value && ca->expr && ca->expr[0] == '/') {
continue;
}
- const char *url = ca->value ? ca->value : ca->expr;
+ const char *url = ca->url_value ? ca->url_value : (ca->value ? ca->value : ca->expr);
if (!url || (url[0] != '/' && url[0] != '`')) {
continue;
}
@@ -2753,7 +2772,7 @@ static void emit_service_edge(cbm_gbuf_t *gbuf, const cbm_gbuf_node_t *source,
* __route__ANY__ twin of the typed edge, which cross-repo matching then
* bound to server handlers of any method. */
if (!http_edge_emitted) {
- detect_url_in_args(gbuf, source, call);
+ detect_url_in_args(gbuf, source, call, svc);
}
}
diff --git a/src/pipeline/pipeline.c b/src/pipeline/pipeline.c
index f8f72916f..36ca30e7f 100644
--- a/src/pipeline/pipeline.c
+++ b/src/pipeline/pipeline.c
@@ -2054,6 +2054,7 @@ static void log_result_census(const char *tag, CBMFileResult **cache, int file_c
str_call_enclosing += census_len(call->enclosing_func_qn);
for (int a = 0; a < call->arg_count && a < CBM_MAX_CALL_ARGS; a++) {
str_call_args += census_len(call->args[a].expr) + census_len(call->args[a].value) +
+ census_len(call->args[a].url_value) +
census_len(call->args[a].keyword);
}
}
diff --git a/tests/test_extraction.c b/tests/test_extraction.c
index aa53b5c87..92580fa88 100644
--- a/tests/test_extraction.c
+++ b/tests/test_extraction.c
@@ -11,6 +11,7 @@
#include "preprocessor.h" /* cbm_export_macro_candidates (#1989) */
#include "../src/foundation/compat.h" /* cbm_clock_gettime (wide-flat scaling guard) */
#include "../src/foundation/compat_fs.h"
+#include <stdint.h>
#include <time.h>
#include "macro_table.h"
#include "result_spill.h"
@@ -5769,6 +5770,439 @@ TEST(extract_go_binary_concat_url_no_literal_suffix_issue1249) {
PASS();
}
+/* Issue #2291: the JS/TS twin of #1249. A BFF that builds its backend URL as
+ * `${process.env.BACKEND_URL}/wallet/topup` from a configurable base must
+ * index the literal path after the base, exactly as `BACKEND_URL + "/x"`
+ * already does. The flattened "{}/wallet/topup" was dropped because it
+ * neither starts with '/' nor carries a scheme, so no HTTP_CALLS edge formed
+ * and the call could never be matched to the backend's route. */
+TEST(extract_ts_template_base_url_issue2291) {
+ CBMFileResult *r = extract("const BACKEND_URL = process.env.BACKEND_URL;\n"
+ "export async function topup(body: string) {\n"
+ " return fetch(`${process.env.BACKEND_URL}/wallet/topup/zibal`, {\n"
+ " method: 'POST', body });\n"
+ "}\n"
+ "export async function tickets() {\n"
+ " return axios.get(`${BACKEND_URL}/tickets/mine`);\n"
+ "}\n"
+ "export async function items(id: string) {\n"
+ " return got(`${BACKEND_URL}/orders/${id}/items`);\n"
+ "}\n",
+ CBM_LANG_TYPESCRIPT, "t", "route.ts");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->has_error);
+
+ const CBMCall *f = find_call_by_callee(r, "fetch");
+ ASSERT_NOT_NULL(f);
+ ASSERT_NOT_NULL(f->first_string_arg);
+ ASSERT_STR_EQ(f->first_string_arg, "/wallet/topup/zibal");
+
+ const CBMCall *g = find_call_by_callee(r, "axios.get");
+ ASSERT_NOT_NULL(g);
+ ASSERT_NOT_NULL(g->first_string_arg);
+ ASSERT_STR_EQ(g->first_string_arg, "/tickets/mine");
+
+ const CBMCall *h = find_call_by_callee(r, "got");
+ ASSERT_NOT_NULL(h);
+ ASSERT_NOT_NULL(h->first_string_arg);
+ /* `got` has no service-table entry: preserve the raw first argument and
+ * carry the recovered path as an explicit candidate for HTTP detection. */
+ ASSERT_STR_EQ(h->first_string_arg, "{}/orders/{}/items");
+ ASSERT_GTE(h->arg_count, 1);
+ ASSERT_NOT_NULL(h->args[0].url_value);
+ ASSERT_STR_EQ(h->args[0].url_value, "/orders/{}/items");
+
+ cbm_free_result(r);
+ PASS();
+}
+
+/* Same issue: with no literal path after the base (`${BASE}${path}`,
+ * `${BASE}/`) there is no route to recover, so none may be fabricated. */
+TEST(extract_ts_template_base_url_no_literal_path_issue2291) {
+ CBMFileResult *r = extract("export async function proxy(path: string) {\n"
+ " return fetch(`${process.env.BACKEND_URL}${path}`);\n"
+ "}\n"
+ "export async function root() {\n"
+ " return axios.get(`${process.env.BACKEND_URL}/`);\n"
+ "}\n"
+ "export function tail(tail: string) {\n"
+ " return axios.post(`${BASE}/${tail}`);\n"
+ "}\n",
+ CBM_LANG_TYPESCRIPT, "t", "proxy.ts");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->has_error);
+
+ const CBMCall *f = find_call_by_callee(r, "fetch");
+ ASSERT_NOT_NULL(f);
+ ASSERT(f->first_string_arg == NULL || f->first_string_arg[0] != '/');
+
+ const CBMCall *g = find_call_by_callee(r, "axios.get");
+ ASSERT_NOT_NULL(g);
+ ASSERT(g->first_string_arg == NULL || g->first_string_arg[0] != '/');
+
+ const CBMCall *h = find_call_by_callee(r, "axios.post");
+ ASSERT_NOT_NULL(h);
+ ASSERT(h->first_string_arg == NULL || h->first_string_arg[0] != '/');
+ ASSERT_GTE(h->arg_count, 1);
+ ASSERT_NULL(h->args[0].url_value);
+
+ cbm_free_result(r);
+ PASS();
+}
+
+/* The call `callee` made inside function `func` (its enclosing QN ends in
+ * ".func"), so one file can hold several calls to the same client. */
+static const CBMCall *find_call_in_func(CBMFileResult *r, const char *callee, const char *func) {
+ size_t fl = strlen(func);
+ for (int i = 0; i < r->calls.count; i++) {
+ const CBMCall *c = &r->calls.items[i];
+ const char *q = c->enclosing_func_qn;
+ if (!c->callee_name || strcmp(c->callee_name, callee) != 0 || !q) {
+ continue;
+ }
+ size_t ql = strlen(q);
+ if (ql > fl && q[ql - fl - 1] == '.' && strcmp(q + ql - fl, func) == 0) {
+ return c;
+ }
+ }
+ return NULL;
+}
+
+/* The URL a call hands to its client: first_string_arg, or "" when none. */
+static const char *url_in(CBMFileResult *r, const char *callee, const char *func) {
+ const CBMCall *c = find_call_in_func(r, callee, func);
+ return (c && c->first_string_arg) ? c->first_string_arg : "";
+}
+
+/* True when the URL is not presented as a path or an absolute URL. */
+static bool url_not_claimed(CBMFileResult *r, const char *callee, const char *func) {
+ const CBMCall *call = find_call_in_func(r, callee, func);
+ if (!call) {
+ return false;
+ }
+ const char *u = call->first_string_arg;
+ return !u || (u[0] != '/' && strstr(u, "://") == NULL);
+}
+
+/* Issue #706: a Python caller that centralises its endpoint URLs in module
+ * constants -- `API_URL = API_BASE_URL + "some/path"` -- lost the URL, so no
+ * HTTP_CALLS edge formed and cross-repo-intelligence reported 0 links. The
+ * concatenation must be folded: resolved parts inline, and an unresolvable
+ * base (an env var) leaves the literal path after it. */
+TEST(extract_py_concat_const_url_issue706) {
+ CBMFileResult *r = extract("import os\n"
+ "import requests\n"
+ "API_BASE_URL = os.environ[\"API_BASE_URL\"]\n"
+ "HOST = \"http://provider:8000\"\n"
+ "PREFIX = \"/v2\"\n"
+ "API_URL = API_BASE_URL + \"some/path\"\n"
+ "URL = API_BASE_URL + \"/foo\"\n"
+ "ORDERS_URL = HOST + \"/orders\"\n"
+ "REPORTS_URL = PREFIX + \"/reports\"\n"
+ "ITEMS_URL = f\"{API_BASE_URL}/items\"\n"
+ "DAILY_URL = REPORTS_URL + \"/daily\"\n"
+ "def send(p):\n"
+ " requests.post(API_URL, json=p)\n"
+ "def send_foo(p):\n"
+ " requests.post(URL, json=p)\n"
+ "def orders():\n"
+ " return requests.get(ORDERS_URL)\n"
+ "def reports():\n"
+ " return requests.get(REPORTS_URL)\n"
+ "def items():\n"
+ " return requests.get(ITEMS_URL)\n"
+ "def daily():\n"
+ " return requests.get(DAILY_URL)\n"
+ "def direct(p):\n"
+ " return requests.post(API_BASE_URL + \"/direct\", json=p)\n"
+ "def inline():\n"
+ " return requests.get(PREFIX + \"/inline\")\n"
+ "def kw(p):\n"
+ " return requests.post(url=API_URL, json=p)\n",
+ CBM_LANG_PYTHON, "t", "client.py");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->has_error);
+
+ ASSERT_STR_EQ(url_in(r, "requests.post", "send"), "/some/path");
+ ASSERT_STR_EQ(url_in(r, "requests.post", "send_foo"), "/foo");
+ ASSERT_STR_EQ(url_in(r, "requests.get", "orders"), "http://provider:8000/orders");
+ ASSERT_STR_EQ(url_in(r, "requests.get", "reports"), "/v2/reports");
+ ASSERT_STR_EQ(url_in(r, "requests.get", "items"), "/items");
+ ASSERT_STR_EQ(url_in(r, "requests.get", "daily"), "/v2/reports/daily");
+ ASSERT_STR_EQ(url_in(r, "requests.post", "direct"), "/direct");
+ ASSERT_STR_EQ(url_in(r, "requests.get", "inline"), "/v2/inline");
+ ASSERT_STR_EQ(url_in(r, "requests.post", "kw"), "/some/path");
+
+ /* A fully resolved fold is an exact argument value; a path left behind by
+ * an unresolvable base is not, so it never reaches the exact-URL slot. */
+ const CBMCall *rep = find_call_in_func(r, "requests.get", "reports");
+ ASSERT_NOT_NULL(rep);
+ ASSERT_GTE(rep->arg_count, 1);
+ ASSERT_NOT_NULL(rep->args[0].value);
+ ASSERT_STR_EQ(rep->args[0].value, "/v2/reports");
+ const CBMCall *snd = find_call_in_func(r, "requests.post", "send");
+ ASSERT_NOT_NULL(snd);
+ ASSERT_GTE(snd->arg_count, 1);
+ ASSERT(snd->args[0].value == NULL || snd->args[0].value[0] != '/');
+
+ cbm_free_result(r);
+ PASS();
+}
+
+/* Same issue, the controls: a URL with nothing literal to recover -- a local
+ * computed value, a bare env-derived base, a base plus "/" or plus another
+ * variable -- must not be turned into a path or an exact URL. */
+TEST(extract_py_url_fold_no_fabrication_issue706) {
+ CBMFileResult *r = extract("import os\n"
+ "import requests\n"
+ "API_BASE_URL = os.environ[\"API_BASE_URL\"]\n"
+ "EMPTY = API_BASE_URL + \"/\"\n"
+ "def compute():\n"
+ " return os.environ.get(\"X\")\n"
+ "def dyn():\n"
+ " u = compute()\n"
+ " return requests.get(u)\n"
+ "def bare():\n"
+ " return requests.get(API_BASE_URL)\n"
+ "def slash():\n"
+ " return requests.get(API_BASE_URL + \"/\")\n"
+ "def empty():\n"
+ " return requests.get(EMPTY)\n"
+ "def two(p):\n"
+ " return requests.get(API_BASE_URL + p)\n",
+ CBM_LANG_PYTHON, "t", "ctl.py");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->has_error);
+
+ ASSERT_TRUE(url_not_claimed(r, "requests.get", "dyn"));
+ ASSERT_TRUE(url_not_claimed(r, "requests.get", "bare"));
+ ASSERT_TRUE(url_not_claimed(r, "requests.get", "slash"));
+ ASSERT_TRUE(url_not_claimed(r, "requests.get", "empty"));
+ ASSERT_TRUE(url_not_claimed(r, "requests.get", "two"));
+
+ cbm_free_result(r);
+ PASS();
+}
+
+/* Issue #1147: a frontend that composes every endpoint from module constants
+ * -- a base constant, template literals over it, and an object-literal map of
+ * endpoints -- extracted none of its API calls. Each template / concatenation
+ * over a resolvable constant must fold to the full path, `OBJ.KEY` of an
+ * object-literal const must resolve, and a base that stays unresolvable
+ * (`${getApiBaseUrl()}`) leaves the path after it. A relative base ('api')
+ * joined to a path is a path under the client's base URL. */
+TEST(extract_ts_const_template_url_issue1147) {
+ CBMFileResult *r = extract(
+ "const BASE = '/api'\n"
+ "const REL = 'api'\n"
+ "const GAMES = '/games'\n"
+ "export const API_ENDPOINTS = {\n"
+ " LOGIN: `${BASE}/users/login`,\n"
+ " USER: `${REL}/users/me`,\n"
+ " GAME_LAUNCH_URL: `${REL}/games/launch`,\n"
+ " NESTED: { DEEP: BASE + '/deep' },\n"
+ "} as const\n"
+ "export const getApiBaseUrl = () => `${API_PROTOCOL}://${process.env.API_DOMAIN}/`\n"
+ "export async function launch() { return fetch(`${BASE}/games/launch`) }\n"
+ "export async function list() { return fetch(`${GAMES}/list`) }\n"
+ "export async function login() { return fetch(API_ENDPOINTS.LOGIN) }\n"
+ "export async function user() {\n"
+ " return fetch(`${getApiBaseUrl()}/${API_ENDPOINTS.USER}`, { method: 'GET' })\n"
+ "}\n"
+ "export async function game(p: unknown) {\n"
+ " return apiClient.post(API_ENDPOINTS.GAME_LAUNCH_URL, p)\n"
+ "}\n"
+ "export async function deep() { return fetch(API_ENDPOINTS.NESTED.DEEP) }\n"
+ "export async function me() { return axios.get(BASE + '/users/me') }\n",
+ CBM_LANG_TYPESCRIPT, "t", "client.ts");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->has_error);
+
+ ASSERT_STR_EQ(url_in(r, "fetch", "launch"), "/api/games/launch");
+ ASSERT_STR_EQ(url_in(r, "fetch", "list"), "/games/list");
+ ASSERT_STR_EQ(url_in(r, "fetch", "login"), "/api/users/login");
+ ASSERT_STR_EQ(url_in(r, "fetch", "user"), "/api/users/me");
+ ASSERT_STR_EQ(url_in(r, "apiClient.post", "game"), "api/games/launch");
+ ASSERT_STR_EQ(url_in(r, "fetch", "deep"), "/api/deep");
+ ASSERT_STR_EQ(url_in(r, "axios.get", "me"), "/api/users/me");
+
+ /* A wrapper client has raw string identity plus an explicit URL candidate.
+ * Only HTTP detection may select the normalized relative path. */
+ const CBMCall *g = find_call_in_func(r, "apiClient.post", "game");
+ ASSERT_NOT_NULL(g);
+ ASSERT_GTE(g->arg_count, 1);
+ ASSERT_NOT_NULL(g->args[0].value);
+ ASSERT_STR_EQ(g->args[0].value, "api/games/launch");
+ ASSERT_NOT_NULL(g->args[0].url_value);
+ ASSERT_STR_EQ(g->args[0].url_value, "/api/games/launch");
+
+ cbm_free_result(r);
+ PASS();
+}
+
+/* Same issue, the controls: a parameter, a bare substitution, a member of an
+ * unknown object, an env-only base, and an unresolvable base followed only by
+ * an unresolvable tail carry no literal path, so none may be fabricated (the
+ * last one used to come out as "/{}"). */
+TEST(extract_ts_url_fold_no_fabrication_issue1147) {
+ CBMFileResult *r =
+ extract("const HEALTH_BASE = process.env.HEALTH_BASE\n"
+ "export async function dynamic(path: string) { return fetch(path) }\n"
+ "export async function dynTpl(x: string) { return fetch(`${x}`) }\n"
+ "export async function missing() { return fetch(API_ENDPOINTS.MISSING) }\n"
+ "export async function tail(t: string) { return fetch(`${getBase()}/${t}`) }\n"
+ "export async function envOnly() { return fetch(HEALTH_BASE) }\n",
+ CBM_LANG_TYPESCRIPT, "t", "ctl.ts");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->has_error);
+
+ ASSERT_TRUE(url_not_claimed(r, "fetch", "dynamic"));
+ ASSERT_TRUE(url_not_claimed(r, "fetch", "dynTpl"));
+ ASSERT_TRUE(url_not_claimed(r, "fetch", "missing"));
+ ASSERT_TRUE(url_not_claimed(r, "fetch", "tail"));
+ ASSERT_TRUE(url_not_claimed(r, "fetch", "envOnly"));
+
+ cbm_free_result(r);
+ PASS();
+}
+
+/* Shared folding must preserve topic/string identity before service resolution. */
+TEST(extract_ts_folded_topics_keep_raw_identity) {
+ CBMFileResult *r = extract(
+ "const TENANT = 'tenant';\n"
+ "const TOPIC = `${TENANT}/events`;\n"
+ "const TOPICS = { EVENTS: `${TENANT}/events` };\n"
+ "const PREFIX = 'tenant/';\n"
+ "const DOUBLE = `${PREFIX}/events`;\n"
+ "const UNKNOWN = `${tenant}/events`;\n"
+ "const UNKNOWN_TOPICS = { EVENTS: `${tenant}/events` };\n"
+ "const PLAIN = 'tenant/events';\n"
+ "export function direct() { mqtt.publish(`${TENANT}/events`, 'payload'); }\n"
+ "export function constant() { mqtt.publish(TOPIC, 'payload'); }\n"
+ "export function member() { mqtt.publish(TOPICS.EVENTS, 'payload'); }\n"
+ "export function literal() { mqtt.publish('tenant/events', 'payload'); }\n"
+ "export function plain() { mqtt.publish(PLAIN, 'payload'); }\n"
+ "export function doubled() { mqtt.publish(`${PREFIX}/events`, 'payload'); }\n"
+ "export function doubledConstant() { mqtt.publish(DOUBLE, 'payload'); }\n"
+ "export function unknown() { mqtt.publish(`${tenant}/events`, 'payload'); }\n"
+ "export function unknownConstant() { mqtt.publish(UNKNOWN, 'payload'); }\n"
+ "export function unknownMember() { mqtt.publish(UNKNOWN_TOPICS.EVENTS, 'payload'); }\n"
+ "export function alias() { bus.publish(TOPICS.EVENTS, 'payload'); }\n",
+ CBM_LANG_TYPESCRIPT, "t", "topics.ts");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->has_error);
+ const char *functions[] = {"direct", "constant", "member", "literal",
+ "plain", "doubled", "doubledConstant"};
+ for (size_t i = 0; i < sizeof(functions) / sizeof(functions[0]); i++) {
+ const CBMCall *c = find_call_in_func(r, "mqtt.publish", functions[i]);
+ const char *expected = i < 5 ? "tenant/events" : "tenant//events";
+ ASSERT_NOT_NULL(c);
+ ASSERT_NOT_NULL(c->first_string_arg);
+ ASSERT_STR_EQ(c->first_string_arg, expected);
+ ASSERT_GTE(c->arg_count, 1);
+ ASSERT_NOT_NULL(c->args[0].value);
+ ASSERT_STR_EQ(c->args[0].value, expected);
+ }
+ const char *unknowns[] = {"unknown", "unknownConstant", "unknownMember"};
+ for (size_t i = 0; i < sizeof(unknowns) / sizeof(unknowns[0]); i++) {
+ const CBMCall *c = find_call_in_func(r, "mqtt.publish", unknowns[i]);
+ ASSERT_NOT_NULL(c);
+ ASSERT_NOT_NULL(c->first_string_arg);
+ ASSERT_STR_EQ(c->first_string_arg, "{}/events");
+ ASSERT_GTE(c->arg_count, 1);
+ ASSERT(c->args[0].value == NULL || c->args[0].value[0] != '/');
+ }
+ const CBMCall *alias = find_call_in_func(r, "bus.publish", "alias");
+ ASSERT_NOT_NULL(alias);
+ ASSERT_STR_EQ(alias->first_string_arg, "tenant/events");
+ ASSERT_GTE(alias->arg_count, 1);
+ ASSERT_STR_EQ(alias->args[0].value, "tenant/events");
+ /* Classification has not happened yet: raw and URL views stay distinct. */
+ ASSERT_NOT_NULL(alias->args[0].url_value);
+ ASSERT_STR_EQ(alias->args[0].url_value, "/tenant/events");
+ cbm_free_result(r);
+ PASS();
+}
+
+TEST(extract_py_folded_topic_keywords_keep_raw_identity) {
+ CBMFileResult *r = extract("TENANT = 'tenant'\n"
+ "TOPIC = f'{TENANT}/events'\n"
+ "PREFIX = 'tenant/'\n"
+ "DOUBLE = PREFIX + '/events'\n"
+ "UNKNOWN = f'{tenant}/events'\n"
+ "def direct():\n mqtt.publish(f'{TENANT}/events', 'payload')\n"
+ "def topic():\n mqtt.publish(topic=TOPIC, payload='x')\n"
+ "def queue():\n mqtt.publish(queue=TOPIC, payload='x')\n"
+ "def channel():\n mqtt.publish(channel=TOPIC, payload='x')\n"
+ "def subject():\n mqtt.publish(subject=TOPIC, payload='x')\n"
+ "def unknown():\n mqtt.publish(topic=UNKNOWN, payload='x')\n"
+ "def doubled():\n mqtt.publish(topic=DOUBLE, payload='x')\n"
+ "def unknown_callee():\n send(topic=TOPIC, payload='x')\n",
+ CBM_LANG_PYTHON, "t", "topics.py");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->has_error);
+ const char *functions[] = {"direct", "topic", "queue", "channel", "subject"};
+ for (size_t i = 0; i < sizeof(functions) / sizeof(functions[0]); i++) {
+ const CBMCall *c = find_call_in_func(r, "mqtt.publish", functions[i]);
+ ASSERT_NOT_NULL(c);
+ ASSERT_STR_EQ(c->first_string_arg, "tenant/events");
+ ASSERT_GTE(c->arg_count, 1);
+ ASSERT_STR_EQ(c->args[0].value, "tenant/events");
+ if (i > 0) {
+ ASSERT_NULL(c->args[0].url_value);
+ }
+ }
+ ASSERT_STR_EQ(url_in(r, "mqtt.publish", "unknown"), "{}/events");
+ ASSERT_STR_EQ(url_in(r, "mqtt.publish", "doubled"), "tenant//events");
+ const CBMCall *c = find_call_in_func(r, "send", "unknown_callee");
+ ASSERT_NOT_NULL(c);
+ ASSERT_STR_EQ(c->first_string_arg, "tenant/events");
+ ASSERT_GTE(c->arg_count, 1);
+ ASSERT_STR_EQ(c->args[0].value, "tenant/events");
+ ASSERT_NULL(c->args[0].url_value);
+ cbm_free_result(r);
+ PASS();
+}
+
+/* #2235's URL slot carries the projection separately; unknown callees stay raw. */
+TEST(extract_ts_folded_config_url_and_exclusions) {
+ CBMFileResult *r =
+ extract("const REL = 'api';\n"
+ "const API_ENDPOINTS = { USER: `${REL}/users/me` };\n"
+ "export function config() { return http({url: API_ENDPOINTS.USER}); }\n"
+ "export function format() { return axios.getUri({url: API_ENDPOINTS.USER}); }\n"
+ "export function register() { app.route({url: API_ENDPOINTS.USER, handler}); }\n"
+ "export function relative() { return fetch(`${REL}/users/me`); }\n",
+ CBM_LANG_TYPESCRIPT, "t", "config.ts");
+ ASSERT_NOT_NULL(r);
+ ASSERT_FALSE(r->has_error);
+ const CBMCall *c = find_call_in_func(r, "http", "config");
+ ASSERT_NOT_NULL(c);
+ ASSERT_STR_EQ(c->first_string_arg, "api/users/me");
+ ASSERT_GTE(c->arg_count, 1);
+ ASSERT_STR_EQ(c->args[0].value, "api/users/me");
+ ASSERT_NOT_NULL(c->args[0].url_value);
+ ASSERT_STR_EQ(c->args[0].url_value, "/api/users/me");
+ const char *callees[] = {"axios.getUri", "app.route"};
+ const char *functions[] = {"format", "register"};
+ for (size_t i = 0; i < sizeof(callees) / sizeof(callees[0]); i++) {
+ c = find_call_in_func(r, callees[i], functions[i]);
+ ASSERT_NOT_NULL(c);
+ ASSERT_NULL(c->first_string_arg);
+ ASSERT_GTE(c->arg_count, 1);
+ ASSERT_NULL(c->args[0].value);
+ ASSERT_NULL(c->args[0].url_value);
+ }
+ c = find_call_in_func(r, "fetch", "relative");
+ ASSERT_NOT_NULL(c);
+ ASSERT_STR_EQ(c->first_string_arg, "/api/users/me");
+ ASSERT_GTE(c->arg_count, 1);
+ ASSERT_STR_EQ(c->args[0].value, "api/users/me");
+ ASSERT_STR_EQ(c->args[0].url_value, "/api/users/me");
+ cbm_free_result(r);
+ PASS();
+}
+
/* Reproduce-first: Java module QN must derive from the CONTAINING DIRECTORY, not
* the filename stem, so a top-level class `Outer` in `Outer.java` is `t.Outer`,
* NOT the doubled `t.Outer.Outer`. The nested method def QN must also equal the
@@ -10234,6 +10668,10 @@ TEST(non_config_language_module_has_no_promoted_description_issue519) {
/* ── Result compaction (cbm_result_compact) ────────────────────────────── */
static const char *COMPACT_PY_SRC = "import os\n"
+ "BASE = 'api'\n"
+ "URL = f'{BASE}/users/me'\n"
+ "def url_candidate():\n"
+ " return client(URL)\n"
"from typing import List\n"
"\n"
"@app.route(\"/items\")\n"
@@ -10301,6 +10739,16 @@ TEST(extract_compact_keeps_every_field_and_shrinks_the_arena) {
size_t cap_before = arena_capacity(&r->arena);
cbm_result_compact(r);
+ const CBMCall *candidate = find_call_in_func(r, "client", "url_candidate");
+ ASSERT_NOT_NULL(candidate);
+ ASSERT_GTE(candidate->arg_count, 1);
+ ASSERT_STR_EQ(candidate->args[0].value, "api/users/me");
+ ASSERT_STR_EQ(candidate->args[0].url_value, "/api/users/me");
+ uintptr_t candidate_addr = (uintptr_t)candidate->args[0].url_value;
+ uintptr_t arena_addr = (uintptr_t)r->arena.blocks[0];
+ ASSERT(candidate_addr >= arena_addr);
+ ASSERT(candidate_addr - arena_addr < r->arena.used);
+
/* One exact block: capacity == bytes used, no dead headroom. */
ASSERT_EQ(r->arena.nblocks, 1);
ASSERT_EQ(arena_capacity(&r->arena), cbm_arena_total(&r->arena));
@@ -10362,6 +10810,7 @@ TEST(extract_compact_keeps_every_field_and_shrinks_the_arena) {
for (int k = 0; k < a->arg_count; k++) {
ASSERT(cmp_str_eq(a->args[k].expr, b->args[k].expr));
ASSERT(cmp_str_eq(a->args[k].value, b->args[k].value));
+ ASSERT(cmp_str_eq(a->args[k].url_value, b->args[k].url_value));
ASSERT(cmp_str_eq(a->args[k].keyword, b->args[k].keyword));
ASSERT_EQ(a->args[k].index, b->args[k].index);
}
@@ -10526,6 +10975,16 @@ TEST(extract_spill_round_trip_keeps_every_field) {
ASSERT(cmp_str_eq(back->module_qn, ref->module_qn));
ASSERT(cmp_list_eq(back->exports, ref->exports));
+ const CBMCall *candidate = find_call_in_func(back, "client", "url_candidate");
+ ASSERT_NOT_NULL(candidate);
+ ASSERT_GTE(candidate->arg_count, 1);
+ ASSERT_STR_EQ(candidate->args[0].value, "api/users/me");
+ ASSERT_STR_EQ(candidate->args[0].url_value, "/api/users/me");
+ uintptr_t candidate_addr = (uintptr_t)candidate->args[0].url_value;
+ uintptr_t arena_addr = (uintptr_t)back->arena.blocks[0];
+ ASSERT(candidate_addr >= arena_addr);
+ ASSERT(candidate_addr - arena_addr < back->arena.used);
+
/* Loading twice yields two independent copies. */
CBMFileResult *again = cbm_result_spill_load(sp, 1);
ASSERT_NOT_NULL(again);
@@ -11365,6 +11824,15 @@ SUITE(extraction) {
RUN_TEST(extract_ts_config_object_url_issue2235);
RUN_TEST(extract_go_binary_concat_url_issue1249);
RUN_TEST(extract_go_binary_concat_url_no_literal_suffix_issue1249);
+ RUN_TEST(extract_ts_template_base_url_issue2291);
+ RUN_TEST(extract_ts_template_base_url_no_literal_path_issue2291);
+ RUN_TEST(extract_py_concat_const_url_issue706);
+ RUN_TEST(extract_py_url_fold_no_fabrication_issue706);
+ RUN_TEST(extract_ts_const_template_url_issue1147);
+ RUN_TEST(extract_ts_url_fold_no_fabrication_issue1147);
+ RUN_TEST(extract_ts_folded_topics_keep_raw_identity);
+ RUN_TEST(extract_py_folded_topic_keywords_keep_raw_identity);
+ RUN_TEST(extract_ts_folded_config_url_and_exclusions);
RUN_TEST(extract_ts_url_builder_issue1009);
RUN_TEST(extract_ts_await_generic_call_issue2210);
RUN_TEST(extract_ts_route_handler_after_named_middleware);
diff --git a/tests/test_pipeline.c b/tests/test_pipeline.c
index f95adce16..9af0b2024 100644
--- a/tests/test_pipeline.c
+++ b/tests/test_pipeline.c
@@ -10115,6 +10115,251 @@ TEST(pipeline_typed_http_call_has_no_arg_url_twin_sequential) {
return typed_http_no_url_twin_case(0);
}
+/* #706 / #1147 end to end: a URL composed from module constants reaches the
+ * HTTP classifier, so the client call forms an HTTP_CALLS edge. Python
+ * `API_URL = API_BASE_URL + "/orders/create"` (env-derived base, literal path
+ * kept) and a TS object-literal endpoint map over a base constant. The
+ * unresolvable control (`requests.get(u)` on a computed value) adds none. */
+TEST(pipeline_url_constant_folding_http_calls_issue706_1147) {
+ char tmp[256];
+ snprintf(tmp, sizeof(tmp), "/tmp/cbm_urlfold_XXXXXX");
+ if (!cbm_mkdtemp(tmp)) {
+ FAIL("tmpdir");
+ }
+
+ write_temp_file(tmp, "svc/client.py",
+ "import os\n"
+ "import requests\n"
+ "API_BASE_URL = os.environ[\"API_BASE_URL\"]\n"
+ "API_URL = API_BASE_URL + \"/orders/create\"\n"
+ "def send(payload):\n"
+ " return requests.post(API_URL, json=payload)\n"
+ "def dyn():\n"
+ " u = os.environ.get(\"X\")\n"
+ " return requests.get(u)\n");
+ write_temp_file(tmp, "web/api.ts",
+ "const BASE = '/api'\n"
+ "export const API_ENDPOINTS = {\n"
+ " USER: `${BASE}/users/me`,\n"
+ "}\n"
+ "export function loadUser(): unknown {\n"
+ " return fetch(API_ENDPOINTS.USER);\n"
+ "}\n");
+
+ char db_path[512];
+ snprintf(db_path, sizeof(db_path), "%s/urlfold.db", tmp);
+ cbm_pipeline_t *p = cbm_pipeline_new(tmp, db_path, CBM_MODE_FULL);
+ ASSERT_NOT_NULL(p);
+ ASSERT_EQ(cbm_pipeline_run(p), 0);
+ const char *project = cbm_pipeline_project_name(p);
+
+ cbm_store_t *s = cbm_store_open_path(db_path);
+ ASSERT_NOT_NULL(s);
+
+ /* Asserted per edge, not by count: a client call may also carry a second,
+ * arg_url-sourced HTTP_CALLS edge for the same path. */
+ cbm_edge_t *edges = NULL;
+ int edge_count = 0;
+ ASSERT_EQ(cbm_store_find_edges_by_type(s, project, "HTTP_CALLS", &edges, &edge_count),
+ CBM_STORE_OK);
+ int py_edges = 0;
+ int ts_edges = 0;
+ int control_edges = 0;
+ for (int i = 0; i < edge_count; i++) {
+ const char *props = edges[i].properties_json ? edges[i].properties_json : "";
+ cbm_node_t src = {0};
+ cbm_store_find_node_by_id(s, edges[i].source_id, &src);
+ if (src.name && strcmp(src.name, "dyn") == 0) {
+ control_edges++;
+ } else if (src.name && strcmp(src.name, "send") == 0 &&
+ strstr(props, "\"url_path\":\"/orders/create\"")) {
+ py_edges++;
+ } else if (src.name && strcmp(src.name, "loadUser") == 0 &&
+ strstr(props, "\"url_path\":\"/api/users/me\"")) {
+ ts_edges++;
+ }
+ cbm_node_free_fields(&src);
+ }
+ cbm_store_free_edges(edges, edge_count);
+ ASSERT_GTE(py_edges, 1);
+ ASSERT_GTE(ts_edges, 1);
+ ASSERT_EQ(control_edges, 0);
+
+ cbm_store_close(s);
+ cbm_pipeline_free(p);
+ th_rmtree(tmp);
+ PASS();
+}
+
+/* Run the same identities through both service resolvers. An import alias is
+ * deliberately absent from the callee-name pattern table until resolution. */
+TEST(pipeline_folded_topics_preserve_identity_sequential_parallel) {
+ char tmp[256];
+ snprintf(tmp, sizeof(tmp), "/tmp/cbm_topicfold_XXXXXX");
+ ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
+ write_temp_file(tmp, "src/topics.ts",
+ "const TENANT = 'tenant';\n"
+ "const TOPIC = `${TENANT}/events`;\n"
+ "const TOPICS = { EVENTS: `${TENANT}/events` };\n"
+ "const PREFIX = 'tenant/';\n"
+ "const DOUBLE = `${PREFIX}/events`;\n"
+ "const UNKNOWN = `${tenant}/events`;\n"
+ "export function literal() { mqtt.publish('tenant/events', 'payload'); }\n"
+ "export function direct() { mqtt.publish(`${TENANT}/events`, 'payload'); }\n"
+ "export function constant() { mqtt.publish(TOPIC, 'payload'); }\n"
+ "export function member() { mqtt.publish(TOPICS.EVENTS, 'payload'); }\n"
+ "export function doubled() { mqtt.publish(DOUBLE, 'payload'); }\n"
+ "export function unknown() { mqtt.publish(UNKNOWN, 'payload'); }\n");
+ write_temp_file(tmp, "src/aliases.py",
+ "from paho.mqtt import publish as send\n"
+ "TENANT = 'tenant'\n"
+ "TOPIC = f'{TENANT}/events'\n"
+ "ABS = f'/{TENANT}/events'\n"
+ "def alias():\n send(TOPIC, 'payload')\n"
+ "def keyword():\n send(topic=TOPIC, payload='x')\n"
+ "def slash_topic():\n send(ABS, 'payload')\n");
+ for (int i = 0; i < 52; i++) {
+ char name[64];
+ char body[128];
+ snprintf(name, sizeof(name), "src/padding%d.ts", i);
+ snprintf(body, sizeof(body), "export function padding%d() { return %d; }\n", i, i);
+ write_temp_file(tmp, name, body);
+ }
+ const char *old_single = getenv("CBM_INDEX_SINGLE_THREAD");
+ char *saved_single = old_single ? strdup(old_single) : NULL;
+ const char *old_workers = getenv("CBM_WORKERS");
+ char *saved_workers = old_workers ? strdup(old_workers) : NULL;
+ int run_rc[2] = {-1, -1};
+ bool opened[2] = {false, false};
+ int matches[2][9] = {{0}};
+ int http_edges[2] = {-1, -1};
+ int invented[2] = {-1, -1};
+ const char *functions[] = {"literal", "direct", "constant", "member", "doubled",
+ "unknown", "alias", "keyword", "slash_topic"};
+ const char *topics[] = {"tenant/events", "tenant/events", "tenant/events",
+ "tenant/events", "tenant//events", "{}/events",
+ "tenant/events", "tenant/events", "/tenant/events"};
+ for (int mode = 0; mode < 2; mode++) {
+ if (mode == 0) {
+ cbm_setenv("CBM_INDEX_SINGLE_THREAD", "1", 1);
+ } else {
+ cbm_unsetenv("CBM_INDEX_SINGLE_THREAD");
+ cbm_setenv("CBM_WORKERS", "4", 1);
+ }
+ char db_path[512];
+ snprintf(db_path, sizeof(db_path), "%s/topics_%d.db", tmp, mode);
+ cbm_pipeline_t *p = cbm_pipeline_new(tmp, db_path, CBM_MODE_FULL);
+ run_rc[mode] = p ? cbm_pipeline_run(p) : -1;
+ const char *project = p ? cbm_pipeline_project_name(p) : NULL;
+ cbm_store_t *s = cbm_store_open_path(db_path);
+ opened[mode] = s != NULL;
+ if (s && project) {
+ for (size_t i = 0; i < sizeof(functions) / sizeof(functions[0]); i++) {
+ matches[mode][i] =
+ named_edge_count(s, project, "ASYNC_CALLS", functions[i], topics[i]);
+ }
+ http_edges[mode] = cbm_store_count_edges_by_type(s, project, "HTTP_CALLS");
+ invented[mode] = count_nodes_named(s, project, "/events");
+ /* Only slash_topic really contains a leading slash. */
+ for (size_t i = 0; i < 8; i++) {
+ invented[mode] +=
+ named_edge_count(s, project, "ASYNC_CALLS", functions[i], "/tenant/events");
+ }
+ }
+ if (s) {
+ cbm_store_close(s);
+ }
+ cbm_pipeline_free(p);
+ }
+ if (saved_single) {
+ cbm_setenv("CBM_INDEX_SINGLE_THREAD", saved_single, 1);
+ free(saved_single);
+ } else {
+ cbm_unsetenv("CBM_INDEX_SINGLE_THREAD");
+ }
+ if (saved_workers) {
+ cbm_setenv("CBM_WORKERS", saved_workers, 1);
+ free(saved_workers);
+ } else {
+ cbm_unsetenv("CBM_WORKERS");
+ }
+ th_rmtree(tmp);
+ for (int mode = 0; mode < 2; mode++) {
+ ASSERT_EQ(run_rc[mode], 0);
+ ASSERT_TRUE(opened[mode]);
+ for (size_t i = 0; i < sizeof(functions) / sizeof(functions[0]); i++) {
+ ASSERT_GTE(matches[mode][i], 1);
+ }
+ ASSERT_EQ(http_edges[mode], 0);
+ ASSERT_EQ(invented[mode], 0);
+ }
+ PASS();
+}
+
+/* Relative endpoint maps still supply the parallel wrapper-client heuristic
+ * through their URL candidate, including the request-config slot from #2235. */
+TEST(pipeline_relative_folded_wrapper_url_candidates) {
+ char tmp[256];
+ snprintf(tmp, sizeof(tmp), "/tmp/cbm_relativefold_XXXXXX");
+ ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
+ write_temp_file(
+ tmp, "src/wrapper.ts",
+ "const REL = 'api';\n"
+ "const API_ENDPOINTS = { GAME_LAUNCH_URL: `${REL}/games/launch` };\n"
+ "function client(url: string) { return url; }\n"
+ "function http(config: {url: string}) { return config; }\n"
+ "export function launch() { return client(API_ENDPOINTS.GAME_LAUNCH_URL); }\n"
+ "export function config() { return http({url: API_ENDPOINTS.GAME_LAUNCH_URL}); }\n");
+ for (int i = 0; i < 52; i++) {
+ char name[64];
+ char body[128];
+ snprintf(name, sizeof(name), "src/padding%d.ts", i);
+ snprintf(body, sizeof(body), "export function padding%d() { return %d; }\n", i, i);
+ write_temp_file(tmp, name, body);
+ }
+ const char *old_single = getenv("CBM_INDEX_SINGLE_THREAD");
+ char *saved_single = old_single ? strdup(old_single) : NULL;
+ const char *old_workers = getenv("CBM_WORKERS");
+ char *saved_workers = old_workers ? strdup(old_workers) : NULL;
+ cbm_unsetenv("CBM_INDEX_SINGLE_THREAD");
+ cbm_setenv("CBM_WORKERS", "4", 1);
+ char db_path[512];
+ snprintf(db_path, sizeof(db_path), "%s/wrappers.db", tmp);
+ cbm_pipeline_t *p = cbm_pipeline_new(tmp, db_path, CBM_MODE_FULL);
+ int run_rc = p ? cbm_pipeline_run(p) : -1;
+ const char *project = p ? cbm_pipeline_project_name(p) : NULL;
+ cbm_store_t *s = cbm_store_open_path(db_path);
+ bool opened = s != NULL;
+ int launch_edges = 0;
+ int config_edges = 0;
+ if (s && project) {
+ launch_edges = named_edge_count(s, project, "HTTP_CALLS", "launch", "/api/games/launch");
+ config_edges = named_edge_count(s, project, "HTTP_CALLS", "config", "/api/games/launch");
+ }
+ if (s) {
+ cbm_store_close(s);
+ }
+ cbm_pipeline_free(p);
+ if (saved_single) {
+ cbm_setenv("CBM_INDEX_SINGLE_THREAD", saved_single, 1);
+ free(saved_single);
+ } else {
+ cbm_unsetenv("CBM_INDEX_SINGLE_THREAD");
+ }
+ if (saved_workers) {
+ cbm_setenv("CBM_WORKERS", saved_workers, 1);
+ free(saved_workers);
+ } else {
+ cbm_unsetenv("CBM_WORKERS");
+ }
+ th_rmtree(tmp);
+ ASSERT_EQ(run_rc, 0);
+ ASSERT_TRUE(opened);
+ ASSERT_GTE(launch_edges, 1);
+ ASSERT_GTE(config_edges, 1);
+ PASS();
+}
+
/* ── Git history pass tests ─────────────────────────────────────── */
TEST(githistory_is_trackable) {
@@ -21224,6 +21469,9 @@ SUITE(pipeline) {
RUN_TEST(pipeline_local_fetch_shadow_not_classified_as_http);
RUN_TEST(pipeline_typed_http_call_has_no_arg_url_twin);
RUN_TEST(pipeline_typed_http_call_has_no_arg_url_twin_sequential);
+ RUN_TEST(pipeline_url_constant_folding_http_calls_issue706_1147);
+ RUN_TEST(pipeline_folded_topics_preserve_identity_sequential_parallel);
+ RUN_TEST(pipeline_relative_folded_wrapper_url_candidates);
/* Git history pass */
RUN_TEST(githistory_is_trackable);
RUN_TEST(githistory_compute_coupling);