windmill-components 1.473.1 → 1.493.3

package/package/components/raw_apps/RawAppInlineScriptsPanel.svelte.d.ts

@@ -0,0 +1,27 @@
+import type { Writable } from 'svelte/store';
+import type { Runnable } from '../apps/inputType';
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const RawAppInlineScriptsPanel: $$__sveltets_2_IsomorphicComponent<{
+    runnables: Writable<Record<string, Runnable>>;
+    selectedRunnable: string | undefined;
+    appPath: string;
+    width?: number | undefined;
+}, {
+    hidePanel: CustomEvent<any>;
+} & {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type RawAppInlineScriptsPanel = InstanceType<typeof RawAppInlineScriptsPanel>;
+export default RawAppInlineScriptsPanel;

package/package/components/raw_apps/RawAppInputsSpecEditor.svelte

@@ -0,0 +1,106 @@
+<script lang="ts">import { addWhitespaceBeforeCapitals, capitalize, classNames } from '../../utils';
+import Tooltip from '../Tooltip.svelte';
+import ToggleButtonGroup from '../common/toggleButton-v2/ToggleButtonGroup.svelte';
+import ToggleButton from '../common/toggleButton-v2/ToggleButton.svelte';
+import { Loader2, Pen, User } from 'lucide-svelte';
+import Toggle from '../Toggle.svelte';
+import StaticInputEditor from '../apps/editor/settingsPanel/inputEditor/StaticInputEditor.svelte';
+import { fieldTypeToTsType } from '../apps/utils';
+export let id;
+export let componentInput;
+export let key;
+export let shouldCapitalize = true;
+export let resourceOnly = false;
+export let tooltip = undefined;
+export let fieldType;
+export let subFieldType;
+export let format;
+export let selectOptions;
+export let placeholder;
+export let customTitle = undefined;
+export let displayType = false;
+export let allowTypeChange = true;
+export let loading = false;
+export let documentationLink = undefined;
+export let markdownTooltip = undefined;
+$: if (componentInput == undefined) {
+    //@ts-ignore
+    componentInput = {
+        type: 'user'
+    };
+}
+</script>
+
+{#if !(resourceOnly && (fieldType !== 'object' || !format?.startsWith('resource-')))}
+	<div class={classNames('flex gap-1', 'flex-col')}>
+		<div class="flex justify-between items-end">
+			<div class="flex flex-row gap-4 items-center">
+				<div class="flex items-center">
+					<span class="!text-2xs font-semibold text-ellipsis text-primary">
+						{customTitle
+							? customTitle
+							: shouldCapitalize
+								? capitalize(addWhitespaceBeforeCapitals(key))
+								: key}
+					</span>
+					{#if loading}
+						<Loader2 size={14} class="animate-spin ml-2" />
+					{/if}
+					{#if tooltip || markdownTooltip}
+						<Tooltip small {documentationLink} {markdownTooltip}>
+							{tooltip}
+						</Tooltip>
+					{/if}
+				</div>
+				{#if displayType}
+					<div class="text-xs text-tertiary mr-1">
+						{fieldType === 'array' && subFieldType
+							? `${fieldTypeToTsType(subFieldType)}[]`
+							: fieldTypeToTsType(fieldType)}
+					</div>
+				{/if}
+			</div>
+
+			<div class={classNames('flex gap-x-2 gap-y-1 justify-end items-center')}>
+				{#if componentInput?.type && allowTypeChange !== false}
+					<ToggleButtonGroup class="h-7" bind:selected={componentInput.type} let:item>
+						<ToggleButton {item} value="user" icon={User} iconOnly tooltip="User Input" />
+						<ToggleButton {item} value="static" icon={Pen} iconOnly tooltip="Static" />
+					</ToggleButtonGroup>
+				{/if}
+			</div>
+		</div>
+
+		{#if componentInput?.type === 'static'}
+			<div class={'w-full flex flex-row-reverse'}>
+				<StaticInputEditor
+					{id}
+					{fieldType}
+					{subFieldType}
+					{selectOptions}
+					{format}
+					{placeholder}
+					bind:componentInput
+				/>
+			</div>
+		{:else if componentInput?.type === 'user' || componentInput?.type == undefined}
+			<span class="text-2xs italic text-tertiary">Field's value is a frontend input</span>
+		{/if}
+		{#if componentInput?.type === 'user' && ((fieldType == 'object' && format?.startsWith('resource-') && format !== 'resource-s3_object') || fieldType == 'resource')}
+			<div class="flex flex-row items-center">
+				<Toggle
+					size="xs"
+					bind:checked={componentInput.allowUserResources}
+					options={{
+						left: 'static resource select only',
+						right: 'resources from users allowed'
+					}}
+				/>
+				<Tooltip
+					>Apps are executed on behalf of publishers. If you want to accept resources from user, you
+					need to enable this (potentially dangerous!)</Tooltip
+				>
+			</div>
+		{/if}
+	</div>
+{/if}

package/package/components/raw_apps/RawAppInputsSpecEditor.svelte.d.ts

@@ -0,0 +1,38 @@
+import type { RichConfiguration } from '../apps/types';
+import type { InputType } from '../apps/inputType';
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const RawAppInputsSpecEditor: $$__sveltets_2_IsomorphicComponent<{
+    id: string;
+    componentInput: RichConfiguration;
+    key: string;
+    shouldCapitalize?: boolean;
+    resourceOnly?: boolean;
+    tooltip?: string | undefined;
+    fieldType: InputType;
+    subFieldType: InputType | undefined;
+    format: string | undefined;
+    selectOptions: string[] | undefined;
+    placeholder: string | undefined;
+    customTitle?: string | undefined;
+    displayType?: boolean;
+    allowTypeChange?: boolean;
+    loading?: boolean;
+    documentationLink?: string | undefined;
+    markdownTooltip?: string | undefined;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type RawAppInputsSpecEditor = InstanceType<typeof RawAppInputsSpecEditor>;
+export default RawAppInputsSpecEditor;

package/package/components/raw_apps/RawAppPreview.svelte

@@ -0,0 +1,19 @@
+<script lang="ts">import {} from '../../stores';
+import RawAppBackgroundRunner from './RawAppBackgroundRunner.svelte';
+import { htmlContent } from './utils';
+export let workspace;
+export let user;
+export let version;
+export let path;
+export let runnables;
+let iframe;
+</script>
+
+<RawAppBackgroundRunner {workspace} editor={false} {iframe} {runnables} {path} />
+
+<iframe
+	bind:this={iframe}
+	title="raw-app"
+	srcDoc={htmlContent(workspace, version, { ctx: user, workspace })}
+	class="w-full h-full min-h-screen bg-white border-none"
+></iframe>

package/package/components/raw_apps/RawAppPreview.svelte.d.ts

@@ -0,0 +1,26 @@
+import { type UserExt } from '../../stores';
+import type { HiddenRunnable } from '../apps/types';
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: Props & {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const RawAppPreview: $$__sveltets_2_IsomorphicComponent<{
+    workspace: string;
+    user: UserExt | undefined;
+    version: number;
+    path: string;
+    runnables: Record<string, HiddenRunnable>;
+}, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type RawAppPreview = InstanceType<typeof RawAppPreview>;
+export default RawAppPreview;

package/package/components/raw_apps/utils.d.ts

@@ -0,0 +1,6 @@
+import type { HiddenRunnable } from '../apps/types';
+export type RawApp = {
+    files: string[];
+};
+export declare function htmlContent(workspace: string, version: number, ctx: any): string;
+export declare function genWmillTs(runnables: Record<string, HiddenRunnable>): string;

package/package/components/raw_apps/utils.js

@@ -0,0 +1,99 @@
+import { schemaToTsType } from '../../schema';
+import { capitalize } from '../../utils';
+export function htmlContent(workspace, version, ctx) {
+    return `
+        <!DOCTYPE html>
+        <html>
+            <head>
+                <meta charset="UTF-8" />
+                <title>App Preview</title>
+                <link rel="stylesheet" href="/api/w/${workspace}/apps/get_data/v/${version}.css" />
+				<script>
+					window.ctx = ${ctx ? JSON.stringify(ctx) : 'undefined'}
+				</script>
+            </head>
+            <body>
+                <div id="root"></div>
+                <script src="/api/w/${workspace}/apps/get_data/v/${version}.js"></script>
+            </body>
+        </html>
+    `;
+}
+function removeStaticFields(schema, fields) {
+    const staticFields = Object.keys(fields).filter((k) => fields[k].type == 'static');
+    return {
+        ...schema,
+        properties: {
+            ...Object.fromEntries(Object.entries(schema.properties ?? {}).filter(([k]) => !staticFields.includes(k)))
+        }
+    };
+}
+function hiddenRunnableToTsType(runnable) {
+    if (runnable.type == 'runnableByName') {
+        if (runnable.inlineScript?.schema) {
+            return schemaToTsType(removeStaticFields(runnable.inlineScript?.schema, runnable.fields));
+        }
+        else {
+            return '{}';
+        }
+    }
+    else if (runnable.type == 'runnableByPath') {
+        return schemaToTsType(removeStaticFields(runnable.schema, runnable.fields));
+    }
+    else {
+        return '{}';
+    }
+}
+export function genWmillTs(runnables) {
+    return `// THIS FILE IS READ-ONLY
+// AND GENERATED AUTOMATICALLY FROM YOUR RUNNABLES
+	
+${Object.entries(runnables)
+        .map(([k, v]) => `export type RunBg${capitalize(k)} = ${hiddenRunnableToTsType(v)}\n`)
+        .join('\n')}
+
+export const runBg = {
+${Object.keys(runnables)
+        .map((k) => `  ${k}: null as unknown as (data: RunBg${capitalize(k)}) => Promise<any>`)
+        .join(',\n')}
+}
+	
+export const runBgAsync = {
+${Object.keys(runnables)
+        .map((k) => `  ${k}: null as unknown as (data: RunBg${capitalize(k)}) => Promise<string>`)
+        .join(',\n')}
+}
+	
+
+export type Job = {
+	type: 'QueuedJob' | 'CompletedJob'
+	id: string
+	created_at: number
+	started_at: number | undefined
+	duration_ms: number
+	success: boolean
+	args: any
+	result: any
+}
+
+/**
+* Execute a job and wait for it to complete and return the completed job
+* @param id
+*/
+// @ts-ignore
+export function waitJob(id: string): Promise<Job> {
+	// implementation passed when bundling/deploying
+	return null as unknown as Promise<Job>
+}
+
+/**
+* Get a job by id and return immediately with the current state of the job
+* @param id
+*/
+// @ts-ignore
+export function getJob(id: string): Promise<Job> {
+	// implementation passed when bundling/deploying
+	return null as unknown as Promise<Job>
+}
+`;
+}

package/package/components/resourceTypesStore.d.ts

@@ -1,3 +1,2 @@
-/// <reference types="svelte" />
 export declare const resourceTypesStore: import("svelte/store").Writable<string[] | undefined>;
 export declare function getResourceTypes(): Promise<string[]>;

package/package/components/runs/BatchReRunOptionsPane.svelte

@@ -0,0 +1,229 @@
+<script lang="ts" module>export {};
+</script>
+
+<script lang="ts">import { Pane, Splitpanes } from 'svelte-splitpanes';
+import PanelSection from '../apps/editor/settingsPanel/common/PanelSection.svelte';
+import { JobService } from '../../gen';
+import { workspaceStore } from '../../stores';
+import InputTransformForm from '../InputTransformForm.svelte';
+import { setContext } from 'svelte';
+import { writable } from 'svelte/store';
+import Alert from '../common/alert/Alert.svelte';
+import { batchReRunDefaultPropertyExpr, buildExtraLibForBatchReruns, mergeSchemasForBatchReruns } from '../jobs/batchReruns';
+import Toggle from '../Toggle.svelte';
+import { TriangleAlert } from 'lucide-svelte';
+let { selectedIds, options = $bindable() } = $props();
+let selected = $state();
+$effect(() => {
+    jobGroupsPromise.then((jobGroups) => {
+        selected = selected
+            ? jobGroups.find((g) => g.script_path === selected?.script_path && g.kind === selected.kind)
+            : jobGroups[0];
+    });
+});
+setContext('PropPickerContext', {
+    flowPropPickerConfig: writable(undefined),
+    pickablePropertiesFiltered: writable(undefined)
+});
+const listSelectedJobsSchemaCache = new Map();
+async function fetchJobGroups() {
+    if (!$workspaceStore)
+        return [];
+    const cachedSelectedIds = selectedIds.filter((id) => listSelectedJobsSchemaCache.has(id));
+    const nonCachedSelectedIds = selectedIds.filter((id) => !listSelectedJobsSchemaCache.has(id));
+    console.log(`Fetching job groups for ${nonCachedSelectedIds.length} jobs, ${cachedSelectedIds.length} cached`);
+    const newJobGroups = nonCachedSelectedIds.length
+        ? await JobService.listSelectedJobGroups({
+            workspace: $workspaceStore,
+            requestBody: nonCachedSelectedIds
+        })
+        : [];
+    // Update cache
+    newJobGroups.forEach((group) => {
+        group.schemas.forEach((s) => {
+            s.job_ids.forEach((job_id) => {
+                listSelectedJobsSchemaCache.set(job_id, group);
+            });
+        });
+    });
+    const jobGroups = newJobGroups;
+    // Handle cached
+    for (const jobId of cachedSelectedIds) {
+        const cachedGroup = listSelectedJobsSchemaCache.get(jobId);
+        const jobSchema = cachedGroup?.schemas.find((s) => s.job_ids.includes(jobId));
+        if (!cachedGroup || !jobSchema) {
+            continue;
+        }
+        const group = jobGroups.find((j) => j.kind === cachedGroup.kind && j.script_path === cachedGroup.script_path) ??
+            jobGroups[jobGroups.push({
+                kind: cachedGroup.kind,
+                script_path: cachedGroup.script_path,
+                schemas: [],
+                latest_schema: cachedGroup.latest_schema
+            }) - 1];
+        const schemaItem = group.schemas.find((s) => s.script_hash === jobSchema.script_hash) ??
+            group.schemas[group.schemas.push({
+                schema: jobSchema.schema,
+                job_ids: [],
+                script_hash: jobSchema.script_hash
+            }) - 1];
+        schemaItem.job_ids.push(jobId);
+    }
+    jobGroups.sort((a, b) => {
+        if (a.script_path < b.script_path)
+            return -1;
+        if (a.script_path > b.script_path)
+            return 1;
+        return 0;
+    });
+    return jobGroups;
+}
+function jobGroupTotalCount(group) {
+    return group.schemas.reduce((p, c) => p + c.job_ids.length, 0);
+}
+function propertyAlwaysExists(propertyName, group) {
+    for (const s of group.schemas) {
+        if (!(propertyName in s.schema.properties))
+            return false;
+    }
+    return true;
+}
+function propertyAlwaysHasSameType(propertyName, group) {
+    let prevType = 'INIT';
+    for (const s of group.schemas) {
+        const currType = s.schema.properties[propertyName]?.type;
+        if (currType === undefined)
+            continue;
+        if (prevType !== 'INIT' && currType !== prevType)
+            return false;
+        prevType = currType;
+    }
+    return true;
+}
+const selectedUsesLatestSchema = $derived(!!selected &&
+    (selected?.kind === 'flow' ||
+        (options[selected.kind][selected.script_path]?.use_latest_version ?? false)));
+const jobGroupsPromise = $derived(selectedIds && fetchJobGroups());
+</script>
+
+<div class="flex-1 flex flex-col">
+	<p class="ml-4 mt-4 text-xs font-semibold truncate">Batch re-run options</p>
+	<div class="border m-4 flex-1">
+		<Splitpanes>
+			<Pane size={32} class="bg-surface-secondary relative">
+				<PanelSection
+					title="Runnables"
+					class="bg-surface-secondary overflow-y-scroll absolute inset-0"
+					id="batch-rerun-options-runnable-list"
+				>
+					<div class="w-full flex flex-col gap-1">
+						{#await jobGroupsPromise then jobGroup}
+							{#each jobGroup as group}
+								<button
+									class="border rounded-sm w-full text-left font-normal py-1.5 px-2 text-2xs flex justify-between {selected?.kind ===
+										group.kind && selected.script_path === group.script_path
+										? 'border-blue-500 bg-blue-100 dark:bg-frost-900/50'
+										: 'hover:bg-blue-50 dark:hover:bg-frost-900/50'}"
+									onclick={() => (selected = group)}
+								>
+									<span class="truncate"> {group.script_path}</span>
+									<span class="text-gray-400">({jobGroupTotalCount(group)})</span>
+								</button>
+							{/each}
+						{/await}
+					</div>
+				</PanelSection>
+			</Pane>
+			<Pane size={68} class="relative">
+				<PanelSection
+					title="Inputs"
+					class="overflow-y-scroll absolute inset-0"
+					id="batch-rerun-options-args"
+				>
+					{#if selected}
+						<div class="text-sm w-full pb-2">
+							<Alert type="info" title="Available expressions :">
+								Use the <code>job</code> object to access data about the original job
+							</Alert>
+						</div>
+						<Toggle
+							checked={selectedUsesLatestSchema}
+							disabled={selected?.kind === 'flow'}
+							on:change={(e) => {
+								if (!selected) return
+								;(options[selected.kind][selected.script_path] ??= {}).use_latest_version =
+									e.detail as boolean
+							}}
+							size="sm"
+							options={{
+								right: 'Always use latest version',
+								rightTooltip:
+									selected.kind === 'flow'
+										? 'Flow jobs will always run on the latest version of the flow'
+										: 'Run all jobs with the latest version of the script even if they originally ran an older version'
+							}}
+						/>
+
+						<!-- Even if we use the latest schema, we want the editor -->
+						<!-- to only lint the original jobs' values -->
+						{@const displayedSchema = selectedUsesLatestSchema
+							? (selected.latest_schema as Schema)
+							: mergeSchemasForBatchReruns(selected.schemas.map((s) => s.schema as Schema))}
+						{@const extraLib = buildExtraLibForBatchReruns({
+							schemas: selected.schemas,
+							script_path: selected.script_path
+						})}
+						<div class="w-full h-full">
+							{#key [selected, displayedSchema]}
+								{#each Object.keys(displayedSchema.properties) as propertyName}
+									<InputTransformForm
+										class="items-start mb-4"
+										arg={options[selected.kind][selected.script_path]?.input_transforms?.[
+											propertyName
+										] ?? {
+											type: 'javascript',
+											expr: batchReRunDefaultPropertyExpr(propertyName, selected.schemas)
+										}}
+										on:change={(e) => {
+											if (!selected) return
+											const newArg = e.detail.arg as InputTransform
+											;((options[selected.kind][selected.script_path] ??= {}).input_transforms ??=
+												{})[propertyName] = newArg
+										}}
+										argName={propertyName}
+										schema={displayedSchema}
+										{extraLib}
+										previousModuleId={undefined}
+										pickablepropertyMap={{
+											hasResume: false,
+											previousId: undefined,
+											priorIds: {},
+											flow_input: {}
+										}}
+										hideHelpButton
+										{...propertyAlwaysExists(propertyName, selected)
+											? {}
+											: {
+													headerTooltip:
+														'This property does not exist on all versions of the script. You can handle different cases in the code below',
+													HeaderTooltipIcon: TriangleAlert,
+													headerTooltipIconClass: 'text-orange-500'
+												}}
+										{...propertyAlwaysHasSameType(propertyName, selected)
+											? {}
+											: {
+													headerTooltip:
+														'This property does not always have the same type depending on the version of the script. You can handle different cases in the code below',
+													HeaderTooltipIcon: TriangleAlert,
+													headerTooltipIconClass: 'text-orange-500'
+												}}
+									/>
+								{/each}
+							{/key}
+						</div>
+					{/if}
+				</PanelSection>
+			</Pane>
+		</Splitpanes>
+	</div>
+</div>

package/package/components/runs/BatchReRunOptionsPane.svelte.d.ts

@@ -0,0 +1,18 @@
+export type BatchReRunOptions = {
+    [kind in 'flow' | 'script']: {
+        [path: string]: {
+            input_transforms?: {
+                [property: string]: InputTransform;
+            };
+            use_latest_version?: boolean;
+        };
+    };
+};
+import { type InputTransform } from '../../gen';
+type $$ComponentProps = {
+    selectedIds: string[];
+    options: BatchReRunOptions;
+};
+declare const BatchReRunOptionsPane: import("svelte").Component<$$ComponentProps, {}, "options">;
+type BatchReRunOptionsPane = ReturnType<typeof BatchReRunOptionsPane>;
+export default BatchReRunOptionsPane;

package/package/components/runs/JobLoader.svelte

@@ -1,4 +1,4 @@
-<script>import { onDestroy, onMount } from 'svelte';
+<script lang="ts">import { onDestroy, onMount } from 'svelte';
 import { JobService, ConcurrencyGroupsService } from '../../gen';
 import { sendUserToast } from '../../toast';
 import { workspaceStore } from '../../stores';
@@ -7,6 +7,7 @@ import { subtractDaysFromDateString } from '../../utils';
 export let jobs;
 export let user;
 export let label = null;
+export let worker = null;
 export let folder;
 export let path;
 export let success = undefined;
@@ -37,6 +38,7 @@ export let allWorkspaces = false;
 export let computeMinAndMax;
 export let lookback = 0;
 export let perPage = undefined;
+export let allowWildcards = false;
 let intervalId;
 let sync = true;
 $: jobKinds = computeJobKinds(jobKindsCat);
@@ -44,6 +46,7 @@ $: ($workspaceStore ||
     (path &&
         label &&
         success &&
+        worker &&
         isSkipped != undefined &&
         jobKinds &&
         concurrencyKey &&
@@ -51,6 +54,7 @@ $: ($workspaceStore ||
         lookback &&
         user &&
         folder &&
+        allowWildcards &&
         schedulePath != undefined &&
         showFutureJobs != undefined &&
         showSchedules != undefined &&
@@ -147,6 +151,7 @@ async function fetchJobs(startedBefore, startedAfter, startedAfterCompletedJobs,
             hasNullParent: jobKindsCat != 'all' ? true : undefined,
             label: label === null || label === '' ? undefined : label,
             tag: tag === null || tag === '' ? undefined : tag,
+            worker: worker === null || worker === '' ? undefined : worker,
             isNotSchedule: showSchedules == false ? true : undefined,
             suspended: success == 'waiting' ? false : success == 'suspended' ? true : undefined,
             scheduledForBeforeNow: showFutureJobs == false || success == 'waiting' || success == 'suspended'
@@ -159,7 +164,8 @@ async function fetchJobs(startedBefore, startedAfter, startedAfterCompletedJobs,
                 ? resultFilter
                 : undefined,
             allWorkspaces: allWorkspaces ? true : undefined,
-            perPage
+            perPage,
+            allowWildcards
         });
     }
     catch (e) {
@@ -201,7 +207,8 @@ async function fetchExtendedJobs(concurrencyKey, startedBefore, startedAfter, st
                 ? resultFilter
                 : undefined,
             allWorkspaces: allWorkspaces ? true : undefined,
-            perPage
+            perPage,
+            allowWildcards
         });
     }
     catch (e) {