@microsoft/rayfin-functions 1.35.0-alpha.1331 → 1.35.0-alpha.1374

package/dist/FunctionClient.d.ts

@@ -31,6 +31,21 @@ export interface FunctionInvocationResponse<TOutput = any> {
 export interface InvokeOptions {
     /** Extra headers to attach to the request. */
     headers?: Record<string, string>;
+    /**
+     * Per-call request timeout in milliseconds, overriding the default function
+     * invocation timeout (`FUNCTIONS_INVOKE_TIMEOUT_MS`, 250s). Use this
+     * for functions that should fail faster than the default.
+     *
+     * Capped at `FUNCTIONS_INVOKE_TIMEOUT_MS` (250s): the Fabric UDF host
+     * aborts the invocation at that ceiling server-side, so a larger value is
+     * silently clamped down. A non-positive value falls back to the default.
+     *
+     * For a no-input function, pass options in the second argument slot
+     * (`invoke(undefined, { timeoutMs })`) rather than as the single
+     * argument, so the option is never confused with a function's own input.
+     * See the note on {@link FunctionClient.invoke}.
+     */
+    timeoutMs?: number;
 }
 /**
  * A strongly-typed client for a single function.
@@ -45,11 +60,17 @@ export declare class FunctionClient<TInput = any, TOutput = any> {
     /**
      * Invoke the function and return its typed output.
      *
-     * @param args - When the function accepts input, pass
-     *   `[params, options?]` — `params` are the input parameters declared
-     *   by the function schema, `options` are optional per-call settings
-     *   (extra headers, etc.). When the function takes no input, pass
-     *   `[options?]` instead.
+     * @param args - Options always go in the **second** argument slot; the
+     *   first argument is always the function's input `params`.
+     *
+     *   - Input functions: `invoke(params)` or `invoke(params, options)`.
+     *   - No-input functions: `invoke()` or `invoke(undefined, options)`.
+     *
+     *   A lone argument is therefore always treated as `params`, never as
+     *   options — so a real input that happens to be shaped like an option
+     *   (for example `{ timeoutMs }`) is never misread. For a no-input function
+     *   the type forbids a lone object, so per-call options such as `timeoutMs`
+     *   must be passed in the second slot (`invoke(undefined, { timeoutMs })`).
      * @returns The function's success-path output, typed as `TOutput`.
      *
      * Failure modes throw — a non-empty `errors` array or a non-success
@@ -75,8 +96,14 @@ export declare class FunctionClient<TInput = any, TOutput = any> {
      *   lastName: 'Lovelace',
      * });
      * console.log(greeting); // typed as string
+     *
+     * // Per-call timeout override (input function):
+     * await client.functions.longRunning.invoke(params, { timeoutMs: 5_000 });
+     *
+     * // No-input function with a per-call timeout override (second slot):
+     * await client.functions.ping.invoke(undefined, { timeoutMs: 5_000 });
      * ```
      */
-    invoke(...args: TInput extends void | Record<string, never> ? [options?: InvokeOptions] : [params: TInput, options?: InvokeOptions]): Promise<TOutput>;
+    invoke(...args: TInput extends void | Record<string, never> ? [params?: undefined, options?: InvokeOptions] : [params: TInput, options?: InvokeOptions]): Promise<TOutput>;
 }
 //# sourceMappingURL=FunctionClient.d.ts.map

package/dist/FunctionClient.js

@@ -6,8 +6,24 @@
  * entry for that function name.
  */
 import { SdkError, NetworkError } from '@microsoft/rayfin-lib';
-import { FUNCTIONS_BASE_PATH } from '@microsoft/rayfin-lib';
+import { FUNCTIONS_BASE_PATH, FUNCTIONS_INVOKE_TIMEOUT_MS, } from '@microsoft/rayfin-lib';
 import { FunctionsError } from './Functions.js';
+/**
+ * Resolve the effective request timeout for an invocation.
+ *
+ * The Fabric UDF host aborts an invocation at `FUNCTIONS_INVOKE_TIMEOUT_MS`
+ * (250s), so a per-call override larger than that can never take effect — it is
+ * clamped down to the ceiling. A missing or non-positive override falls back to
+ * the default (a `0`/negative value would otherwise abort the request instantly).
+ */
+function resolveInvokeTimeout(timeoutMs) {
+    if (typeof timeoutMs !== 'number' ||
+        !Number.isFinite(timeoutMs) ||
+        timeoutMs <= 0) {
+        return FUNCTIONS_INVOKE_TIMEOUT_MS;
+    }
+    return Math.min(timeoutMs, FUNCTIONS_INVOKE_TIMEOUT_MS);
+}
 /**
  * A strongly-typed client for a single function.
  *
@@ -24,11 +40,17 @@ export class FunctionClient {
     /**
      * Invoke the function and return its typed output.
      *
-     * @param args - When the function accepts input, pass
-     *   `[params, options?]` — `params` are the input parameters declared
-     *   by the function schema, `options` are optional per-call settings
-     *   (extra headers, etc.). When the function takes no input, pass
-     *   `[options?]` instead.
+     * @param args - Options always go in the **second** argument slot; the
+     *   first argument is always the function's input `params`.
+     *
+     *   - Input functions: `invoke(params)` or `invoke(params, options)`.
+     *   - No-input functions: `invoke()` or `invoke(undefined, options)`.
+     *
+     *   A lone argument is therefore always treated as `params`, never as
+     *   options — so a real input that happens to be shaped like an option
+     *   (for example `{ timeoutMs }`) is never misread. For a no-input function
+     *   the type forbids a lone object, so per-call options such as `timeoutMs`
+     *   must be passed in the second slot (`invoke(undefined, { timeoutMs })`).
      * @returns The function's success-path output, typed as `TOutput`.
      *
      * Failure modes throw — a non-empty `errors` array or a non-success
@@ -54,33 +76,22 @@ export class FunctionClient {
      *   lastName: 'Lovelace',
      * });
      * console.log(greeting); // typed as string
+     *
+     * // Per-call timeout override (input function):
+     * await client.functions.longRunning.invoke(params, { timeoutMs: 5_000 });
+     *
+     * // No-input function with a per-call timeout override (second slot):
+     * await client.functions.ping.invoke(undefined, { timeoutMs: 5_000 });
      * ```
      */
     async invoke(...args) {
         try {
-            // Unpack the variadic args – when TInput is void the first arg is options.
-            let parameters;
-            let options;
-            if (args.length === 0) {
-                // No-arg call: `fn.invoke()`
-            }
-            else if (args.length === 1) {
-                // Could be `invoke(params)` or `invoke(options)` for void-input fns
-                const first = args[0];
-                if (first &&
-                    typeof first === 'object' &&
-                    'headers' in first &&
-                    Object.keys(first).every((k) => k === 'headers')) {
-                    options = first;
-                }
-                else {
-                    parameters = first;
-                }
-            }
-            else {
-                parameters = args[0];
-                options = args[1];
-            }
+            // Options always live in the second slot; the first argument is always
+            // params (`undefined` for a no-input function). A lone argument is
+            // therefore never reinterpreted as options, so a real input shaped like
+            // `{ timeoutMs }` is sent verbatim — no key-sniffing needed.
+            const parameters = args[0];
+            const options = args[1];
             // When a `functionsBaseUrl` is configured on the ApiClient (e.g. by
             // local-debug flows that point at a `func start` process), invoke the
             // function directly against `${functionsBaseUrl}/api/<name>` using the
@@ -91,7 +102,14 @@ export class FunctionClient {
             const url = functionsBaseUrl
                 ? `${functionsBaseUrl}/api/${this.functionName}`
                 : `${FUNCTIONS_BASE_PATH}/${this.functionName}/invoke`;
-            const response = await this.apiClient.post(url, parameters ?? {}, { headers: options?.headers });
+            const response = await this.apiClient.post(url, parameters ?? {}, {
+                headers: options?.headers,
+                // The server aborts a UDF invocation at FUNCTIONS_INVOKE_TIMEOUT_MS
+                // (250s), so a larger client timeout can never be honoured — clamp the
+                // per-call override to that ceiling. Non-positive values fall back to
+                // the default rather than timing out instantly.
+                timeout: resolveInvokeTimeout(options?.timeoutMs),
+            });
             // Check for errors in the response body
             if (response.errors && response.errors.length > 0) {
                 const errorMessage = typeof response.errors[0] === 'string'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@microsoft/rayfin-functions",
-  "version": "1.35.0-alpha.1331",
+  "version": "1.35.0-alpha.1374",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,7 +19,7 @@
     "rimraf": "~6.0.1"
   },
   "dependencies": {
-    "@microsoft/rayfin-lib": "1.35.0-alpha.1331"
+    "@microsoft/rayfin-lib": "1.35.0-alpha.1374"
   },
   "publishConfig": {
     "registry": "https://npm.pkg.github.com",