create-caspian-app 0.0.21 → 0.0.23

package/dist/main.py

@@ -355,10 +355,26 @@ def register_single_route(url_pattern: str, file_path: str):
             if not hasattr(module, 'page'):
                 raise AttributeError(f"Missing 'def page():' in {file_path}")
 
+            # === INTELLIGENT ARGUMENT BINDING ===
+            # Detects if the page function needs 'request' or traditional kwargs
+            sig = inspect.signature(module.page)
+            call_kwargs = {}
+            call_args = []
+
+            # Legacy support: If path params exist, pass them as first positional arg
+            # UNLESS the function signature looks like it only wants request
+            if kwargs:
+                call_args.append(kwargs)
+
+            # Injection support: If 'request' is in signature, pass it
+            if 'request' in sig.parameters:
+                call_kwargs['request'] = request
+
             if inspect.iscoroutinefunction(module.page):
-                result = await (module.page(kwargs) if kwargs else module.page())
+                result = await module.page(*call_args, **call_kwargs)
             else:
-                result = module.page(kwargs) if kwargs else module.page()
+                result = module.page(*call_args, **call_kwargs)
+            # ====================================
 
             if isinstance(result, Response):
                 return result

package/dist/settings/component-map.ts

@@ -71,7 +71,7 @@ function extractDictKeysFromNode(node: Parser.SyntaxNode): string[] {
 }
 
 /**
- * Extracts values from a Literal[...] type node
+ * Extracts values from a Literal[...] or types from Union[...] node
  */
 function extractLiteralValues(node: Parser.SyntaxNode): string[] {
   const values: string[] = [];
@@ -85,19 +85,52 @@ function extractLiteralValues(node: Parser.SyntaxNode): string[] {
     typeName = node.children.find((c) => c.type === "identifier")?.text;
   }
 
-  if (typeName !== "Literal") return values;
+  // --- Handle Literal[...] ---
+  if (typeName === "Literal") {
+    const findValues = (n: Parser.SyntaxNode) => {
+      if (n.type === "string") {
+        // Strip quotes from strings
+        values.push(n.text.replace(/^['"]|['"]$/g, ""));
+      } else if (
+        ["integer", "float", "true", "false", "none"].includes(n.type)
+      ) {
+        // Capture raw values for primitives (e.g. Literal[1, True, None])
+        values.push(n.text);
+      }
+      for (const child of n.children) {
+        findValues(child);
+      }
+    };
+    findValues(node);
+  }
 
-  const findStrings = (n: Parser.SyntaxNode) => {
-    if (n.type === "string") {
-      values.push(n.text.replace(/^['"]|['"]$/g, ""));
-      return;
-    }
-    for (const child of n.children) {
-      findStrings(child);
+  // --- Handle Union[...] ---
+  else if (typeName === "Union") {
+    for (const child of node.children) {
+      // Skip the "Union" keyword itself and punctuation
+      if (
+        (child.type === "identifier" && child.text === "Union") ||
+        ["[", "]", ","].includes(child.type)
+      ) {
+        continue;
+      }
+
+      // Capture Types (bool, str, etc.) and None
+      if (
+        child.type === "identifier" ||
+        child.type === "none" ||
+        child.type === "type" ||
+        child.type === "primitive_type"
+      ) {
+        values.push(child.text);
+      }
+      // Recursively handle nested structures (e.g. Union[str, Literal["a"]])
+      else if (child.type === "subscript" || child.type === "generic_type") {
+        values.push(...extractLiteralValues(child));
+      }
     }
-  };
+  }
 
-  findStrings(node);
   return values;
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-caspian-app",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "Scaffold a new Caspian project (FastAPI-powered reactive Python framework).",
   "main": "dist/index.js",
   "type": "module",