refactor(rpc): rename :imported_ts_func to :runtime_expr for endpoint configuration

Author: Torkan

README.md

@@ -1448,8 +1448,8 @@ config :ash_typescript,
   validate_endpoint: "/rpc/validate",
 
   # Dynamic endpoints (for separate frontend projects)
-  # run_endpoint: {:imported_ts_func, "CustomTypes.getRunEndpoint"},
-  # validate_endpoint: {:imported_ts_func, "CustomTypes.getValidateEndpoint"},
+  # run_endpoint: {:runtime_expr, "CustomTypes.getRunEndpoint()"},
+  # validate_endpoint: {:runtime_expr, "process.env.RPC_VALIDATE_ENDPOINT"},
 
   # Custom error response handling
   # rpc_error_response_handler: "MyAppConfig.handleRpcResponseError",
@@ -1542,7 +1542,7 @@ Customize how field names are formatted in generated TypeScript:
 
 ### Dynamic RPC Endpoints
 
-For separate frontend projects or different deployment environments, AshTypescript supports dynamic endpoint configuration through imported TypeScript functions.
+For separate frontend projects or different deployment environments, AshTypescript supports dynamic endpoint configuration through runtime TypeScript expressions.
 
 #### Why Use Dynamic Endpoints?
 
@@ -1551,29 +1551,74 @@ When building a separate frontend project (not embedded in your Phoenix app), yo
 - **Staging**: `https://staging-api.myapp.com/rpc/run`
 - **Production**: `https://api.myapp.com/rpc/run`
 
-Instead of hardcoding the endpoint in your Elixir config, you can reference a TypeScript function that returns the appropriate endpoint based on your frontend's environment.
+Instead of hardcoding the endpoint in your Elixir config, you can use runtime expressions that will be evaluated at runtime in your TypeScript code.
 
-#### Configuration
+#### Configuration Options
 
-Configure endpoints to use imported TypeScript functions instead of string literals:
+You can use various runtime expressions depending on your needs:
 
 ```elixir
 # config/config.exs
 config :ash_typescript,
-  # Use function references instead of string literals
-  run_endpoint: {:imported_ts_func, "MyAppConfig.getRunEndpoint"},
-  validate_endpoint: {:imported_ts_func, "MyAppConfig.getValidateEndpoint"},
+  # Option 1: Use environment variables directly (Node.js)
+  run_endpoint: {:runtime_expr, "process.env.RPC_RUN_ENDPOINT || '/rpc/run'"},
+  validate_endpoint: {:runtime_expr, "process.env.RPC_VALIDATE_ENDPOINT || '/rpc/validate'"},
 
-  # Import the module containing your endpoint functions
-  import_into_generated: [
-    %{
-      import_name: "MyAppConfig",
-      file: "./myAppConfig"
-    }
-  ]
+  # Option 2: Use Vite environment variables
+  # run_endpoint: {:runtime_expr, "import.meta.env.VITE_RPC_RUN_ENDPOINT || '/rpc/run'"},
+  # validate_endpoint: {:runtime_expr, "import.meta.env.VITE_RPC_VALIDATE_ENDPOINT || '/rpc/validate'"},
+
+  # Option 3: Use custom functions from imported modules
+  # run_endpoint: {:runtime_expr, "MyAppConfig.getRunEndpoint()"},
+  # validate_endpoint: {:runtime_expr, "MyAppConfig.getValidateEndpoint()"},
+
+  # Option 4: Use complex expressions with conditionals
+  # run_endpoint: {:runtime_expr, "window.location.hostname === 'localhost' ? 'http://localhost:4000/rpc/run' : '/rpc/run'"},
+
+  # Import modules if needed for custom functions (Option 3)
+  # import_into_generated: [
+  #   %{
+  #     import_name: "MyAppConfig",
+  #     file: "./myAppConfig"
+  #   }
+  # ]
 ```
 
-#### TypeScript Implementation
+#### Usage Examples
+
+**Option 1: Environment Variables (Node.js/Next.js)**
+
+```bash
+# .env.local
+RPC_RUN_ENDPOINT=http://localhost:4000/rpc/run
+RPC_VALIDATE_ENDPOINT=http://localhost:4000/rpc/validate
+
+# .env.production
+RPC_RUN_ENDPOINT=https://api.myapp.com/rpc/run
+RPC_VALIDATE_ENDPOINT=https://api.myapp.com/rpc/validate
+```
+
+Generated TypeScript will use the environment variables directly:
+```typescript
+const response = await fetchFunction(process.env.RPC_RUN_ENDPOINT || '/rpc/run', fetchOptions);
+```
+
+**Option 2: Vite Environment Variables**
+
+```bash
+# .env.development
+VITE_RPC_RUN_ENDPOINT=http://localhost:4000/rpc/run
+
+# .env.production
+VITE_RPC_RUN_ENDPOINT=https://api.myapp.com/rpc/run
+```
+
+Generated TypeScript:
+```typescript
+const response = await fetchFunction(import.meta.env.VITE_RPC_RUN_ENDPOINT || '/rpc/run', fetchOptions);
+```
+
+**Option 3: Custom Functions**
 
 Create a TypeScript file with functions that return the appropriate endpoints:
 
@@ -1596,33 +1641,55 @@ export function getValidateEndpoint(): string {
 // Production: VITE_API_URL=https://api.myapp.com
 ```
 
+**Option 4: Complex Conditional Expressions**
+
+For browser-based applications that need different endpoints based on hostname:
+
+```elixir
+config :ash_typescript,
+  run_endpoint: {:runtime_expr, """
+  (window.location.hostname === 'localhost'
+    ? 'http://localhost:4000/rpc/run'
+    : `https://${window.location.hostname}/rpc/run`)
+  """}
+```
+
+This allows dynamic endpoint resolution based on the current page's hostname.
+
 #### Generated Code
 
-The generated RPC functions will call your endpoint functions instead of using hardcoded strings:
+The generated RPC functions will use your runtime expressions directly in the code:
 
 ```typescript
-// Generated in ash_rpc.ts
-import * as CustomTypes from "./customTypes";
+// Example 1: With environment variables
+// config: run_endpoint: {:runtime_expr, "process.env.RPC_RUN_ENDPOINT || '/rpc/run'"}
 
 export async function createTodo<Fields extends CreateTodoFields>(
   config: CreateTodoConfig<Fields>
 ): Promise<CreateTodoResult<Fields>> {
-  const headers: Record<string, string> = {
-    "Content-Type": "application/json",
-    ...config.headers,
-  };
+  // Runtime expression is embedded directly
+  const response = await fetchFunction(
+    process.env.RPC_RUN_ENDPOINT || '/rpc/run',
+    fetchOptions
+  );
+  // ... rest of implementation
+}
+```
 
-  const fetchFunction = config.customFetch || fetch;
-  const fetchOptions: RequestInit = {
-    ...config.fetchOptions,
-    method: "POST",
-    headers,
-    body: JSON.stringify(payload),
-  };
+```typescript
+// Example 2: With custom function
+// config: run_endpoint: {:runtime_expr, "MyAppConfig.getRunEndpoint()"}
 
-  // Calls your function instead of using a hardcoded string
-  const response = await fetchFunction(CustomTypes.MyAppConfig(), fetchOptions);
+import * as MyAppConfig from "./myAppConfig";
 
+export async function createTodo<Fields extends CreateTodoFields>(
+  config: CreateTodoConfig<Fields>
+): Promise<CreateTodoResult<Fields>> {
+  // Custom function is called at runtime
+  const response = await fetchFunction(
+    MyAppConfig.getRunEndpoint(),
+    fetchOptions
+  );
   // ... rest of implementation
 }
 ```

lib/ash_typescript/rpc/codegen.ex

@@ -19,23 +19,23 @@ defmodule AshTypescript.Rpc.Codegen do
 
   Accepts either:
   - A string: Returns the string as a quoted literal for direct embedding
-  - A tuple {:imported_ts_func, "FunctionName"}: Returns a function call expression
+  - A tuple {:runtime_expr, "expression"}: Returns the expression as-is for runtime evaluation
 
   ## Examples
 
       iex> format_endpoint_for_typescript("/rpc/run")
       "\"/rpc/run\""
 
-      iex> format_endpoint_for_typescript({:imported_ts_func, "CustomTypes.getRunEndpoint"})
+      iex> format_endpoint_for_typescript({:runtime_expr, "CustomTypes.getRunEndpoint()"})
       "CustomTypes.getRunEndpoint()"
   """
   def format_endpoint_for_typescript(endpoint) when is_binary(endpoint) do
     "\"#{endpoint}\""
   end
 
-  def format_endpoint_for_typescript({:imported_ts_func, function_name})
-      when is_binary(function_name) do
-    "#{function_name}()"
+  def format_endpoint_for_typescript({:runtime_expr, expression})
+      when is_binary(expression) do
+    expression
   end
 
   @doc """

test/ash_typescript/rpc/endpoint_configuration_test.exs

@@ -16,20 +16,20 @@ defmodule AshTypescript.Rpc.EndpointConfigurationTest do
                "\"http://localhost:4000/api/rpc\""
     end
 
-    test "formats function reference as function call" do
-      assert Codegen.format_endpoint_for_typescript({:imported_ts_func, "getRunEndpoint"}) ==
+    test "formats runtime expression as-is" do
+      assert Codegen.format_endpoint_for_typescript({:runtime_expr, "getRunEndpoint()"}) ==
                "getRunEndpoint()"
     end
 
-    test "formats namespaced function reference as function call" do
+    test "formats namespaced runtime expression as-is" do
       assert Codegen.format_endpoint_for_typescript(
-               {:imported_ts_func, "CustomTypes.getRunEndpoint"}
+               {:runtime_expr, "CustomTypes.getRunEndpoint()"}
              ) == "CustomTypes.getRunEndpoint()"
     end
 
-    test "formats deeply namespaced function reference" do
+    test "formats deeply namespaced runtime expression as-is" do
       assert Codegen.format_endpoint_for_typescript(
-               {:imported_ts_func, "Config.Endpoints.getRunEndpoint"}
+               {:runtime_expr, "Config.Endpoints.getRunEndpoint()"}
              ) == "Config.Endpoints.getRunEndpoint()"
     end
   end
@@ -47,14 +47,14 @@ defmodule AshTypescript.Rpc.EndpointConfigurationTest do
       assert String.contains?(generated, ~s[fetchFunction("/rpc/validate"])
     end
 
-    test "generates correct TypeScript with function reference endpoints" do
+    test "generates correct TypeScript with runtime expression endpoints" do
       {:ok, generated} =
         Codegen.generate_typescript_types(:ash_typescript,
-          run_endpoint: {:imported_ts_func, "CustomTypes.getRunEndpoint"},
-          validate_endpoint: {:imported_ts_func, "CustomTypes.getValidateEndpoint"}
+          run_endpoint: {:runtime_expr, "CustomTypes.getRunEndpoint()"},
+          validate_endpoint: {:runtime_expr, "CustomTypes.getValidateEndpoint()"}
         )
 
-      # Should contain the function call (without quotes) in fetch call
+      # Should contain the runtime expression (without quotes) in fetch call
       assert String.contains?(generated, "fetchFunction(CustomTypes.getRunEndpoint()")
       assert String.contains?(generated, "fetchFunction(CustomTypes.getValidateEndpoint()")
 
@@ -65,11 +65,11 @@ defmodule AshTypescript.Rpc.EndpointConfigurationTest do
     test "generates correct TypeScript with mixed endpoint types" do
       {:ok, generated} =
         Codegen.generate_typescript_types(:ash_typescript,
-          run_endpoint: {:imported_ts_func, "CustomTypes.getRunEndpoint"},
+          run_endpoint: {:runtime_expr, "CustomTypes.getRunEndpoint()"},
           validate_endpoint: "/rpc/validate"
         )
 
-      # run_endpoint should be a function call
+      # run_endpoint should be a runtime expression
       assert String.contains?(generated, "fetchFunction(CustomTypes.getRunEndpoint()")
 
       # validate_endpoint should be a string literal