windmill-components 1.36.2 → 1.46.1

package/gen/services/JobService.js

@@ -45,6 +45,25 @@ export class JobService {
             mediaType: 'application/json',
         });
     }
+    /**
+     * get job result by id
+     * @returns any job result
+     * @throws ApiError
+     */
+    static resultById({ workspace, flowJobId, nodeId, skipDirect, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/result_by_id/{flow_job_id}/{node_id}',
+            path: {
+                'workspace': workspace,
+                'flow_job_id': flowJobId,
+                'node_id': nodeId,
+            },
+            query: {
+                'skip_direct': skipDirect,
+            },
+        });
+    }
     /**
      * run flow by path
      * @returns string job created
@@ -283,36 +302,62 @@ export class JobService {
             mediaType: 'application/json',
         });
     }
+    /**
+     * create an HMac signature given a job id and a resume id
+     * @returns string job signature
+     * @throws ApiError
+     */
+    static createJobSignature({ workspace, id, resumeId, approver, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/job_signature/{id}/{resume_id}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+                'resume_id': resumeId,
+            },
+            query: {
+                'approver': approver,
+            },
+        });
+    }
     /**
      * resume a job for a suspended flow
-     * @returns void
+     * @returns string job resumed
      * @throws ApiError
      */
-    static resumeSuspendedJob({ workspace, id, payload, }) {
+    static resumeSuspendedJobGet({ workspace, id, resumeId, signature, approver, }) {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/w/{workspace}/jobs/resume/{id}',
+            url: '/w/{workspace}/jobs/resume/{id}/{resume_id}/{signature}',
             path: {
                 'workspace': workspace,
                 'id': id,
+                'resume_id': resumeId,
+                'signature': signature,
             },
             query: {
-                'payload': payload,
+                'approver': approver,
             },
         });
     }
     /**
      * resume a job for a suspended flow
-     * @returns void
+     * @returns string job resumed
      * @throws ApiError
      */
-    static resumeSuspendedJob1({ workspace, id, requestBody, }) {
+    static resumeSuspendedJobPost({ workspace, id, resumeId, signature, requestBody, approver, }) {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/w/{workspace}/jobs/resume/{id}',
+            url: '/w/{workspace}/jobs/resume/{id}/{resume_id}/{signature}',
             path: {
                 'workspace': workspace,
                 'id': id,
+                'resume_id': resumeId,
+                'signature': signature,
+            },
+            query: {
+                'approver': approver,
             },
             body: requestBody,
             mediaType: 'application/json',
@@ -320,37 +365,64 @@ export class JobService {
     }
     /**
      * cancel a job for a suspended flow
-     * @returns void
+     * @returns string job resumed
      * @throws ApiError
      */
-    static cancelSuspendedJob({ workspace, id, payload, }) {
+    static cancelSuspendedJobGet({ workspace, id, resumeId, signature, approver, }) {
         return __request(OpenAPI, {
             method: 'GET',
-            url: '/w/{workspace}/jobs/cancel/{id}',
+            url: '/w/{workspace}/jobs/cancel/{id}/{resume_id}/{signature}',
             path: {
                 'workspace': workspace,
                 'id': id,
+                'resume_id': resumeId,
+                'signature': signature,
             },
             query: {
-                'payload': payload,
+                'approver': approver,
             },
         });
     }
     /**
      * cancel a job for a suspended flow
-     * @returns void
+     * @returns string job resumed
      * @throws ApiError
      */
-    static cancelSuspendedJob1({ workspace, id, requestBody, }) {
+    static cancelSuspendedJobPost({ workspace, id, resumeId, signature, requestBody, approver, }) {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/w/{workspace}/jobs/cancel/{id}',
+            url: '/w/{workspace}/jobs/cancel/{id}/{resume_id}/{signature}',
             path: {
                 'workspace': workspace,
                 'id': id,
+                'resume_id': resumeId,
+                'signature': signature,
+            },
+            query: {
+                'approver': approver,
             },
             body: requestBody,
             mediaType: 'application/json',
         });
     }
+    /**
+     * get parent flow job of suspended job
+     * @returns any parent flow details
+     * @throws ApiError
+     */
+    static getSuspendedJobFlow({ workspace, id, resumeId, signature, approver, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/jobs/get_flow/{id}/{resume_id}/{signature}',
+            path: {
+                'workspace': workspace,
+                'id': id,
+                'resume_id': resumeId,
+                'signature': signature,
+            },
+            query: {
+                'approver': approver,
+            },
+        });
+    }
 }

package/gen/services/OauthService.d.ts

@@ -1,13 +1,13 @@
-import type { SlackToken } from '../models/SlackToken';
 import type { TokenResponse } from '../models/TokenResponse';
 import type { CancelablePromise } from '../core/CancelablePromise';
 export declare class OauthService {
     /**
      * connect slack callback
-     * @returns SlackToken slack token
+     * @returns string slack token
      * @throws ApiError
      */
-    static connectSlackCallback({ requestBody, }: {
+    static connectSlackCallback({ workspace, requestBody, }: {
+        workspace: string;
         /**
          * code endpoint
          */
@@ -15,7 +15,7 @@ export declare class OauthService {
             code: string;
             state: string;
         };
-    }): CancelablePromise<SlackToken>;
+    }): CancelablePromise<string>;
     /**
      * connect callback
      * @returns TokenResponse oauth token
@@ -55,7 +55,7 @@ export declare class OauthService {
      */
     static refreshToken({ workspace, id, requestBody, }: {
         workspace: string;
-        id: string;
+        id: number;
         /**
          * variable path
          */
@@ -70,7 +70,7 @@ export declare class OauthService {
      */
     static disconnectAccount({ workspace, id, }: {
         workspace: string;
-        id: string;
+        id: number;
     }): CancelablePromise<string>;
     /**
      * disconnect slack
@@ -80,15 +80,6 @@ export declare class OauthService {
     static disconnectSlack({ workspace, }: {
         workspace: string;
     }): CancelablePromise<string>;
-    /**
-     * set workspace's slack
-     * @returns string workspace slack is set
-     * @throws ApiError
-     */
-    static setWorkspaceSlack({ workspace, requestBody, }: {
-        workspace: string;
-        requestBody: SlackToken;
-    }): CancelablePromise<string>;
     /**
      * list oauth logins
      * @returns string list of oauth login clients

package/gen/services/OauthService.js

@@ -3,13 +3,16 @@ import { request as __request } from '../core/request';
 export class OauthService {
     /**
      * connect slack callback
-     * @returns SlackToken slack token
+     * @returns string slack token
      * @throws ApiError
      */
-    static connectSlackCallback({ requestBody, }) {
+    static connectSlackCallback({ workspace, requestBody, }) {
         return __request(OpenAPI, {
             method: 'POST',
-            url: '/oauth/connect_slack_callback',
+            url: '/w/{workspace}/oauth/connect_slack_callback',
+            path: {
+                'workspace': workspace,
+            },
             body: requestBody,
             mediaType: 'application/json',
         });
@@ -92,22 +95,6 @@ export class OauthService {
             },
         });
     }
-    /**
-     * set workspace's slack
-     * @returns string workspace slack is set
-     * @throws ApiError
-     */
-    static setWorkspaceSlack({ workspace, requestBody, }) {
-        return __request(OpenAPI, {
-            method: 'POST',
-            url: '/w/{workspace}/oauth/set_workspace_slack',
-            path: {
-                'workspace': workspace,
-            },
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
     /**
      * list oauth logins
      * @returns string list of oauth login clients

package/gen/services/ResourceService.d.ts

@@ -41,13 +41,22 @@ export declare class ResourceService {
     }): CancelablePromise<string>;
     /**
      * get resource
-     * @returns Resource resource deleted
+     * @returns Resource resource
      * @throws ApiError
      */
     static getResource({ workspace, path, }: {
         workspace: string;
         path: string;
     }): CancelablePromise<Resource>;
+    /**
+     * get resource value
+     * @returns any resource value
+     * @throws ApiError
+     */
+    static getResourceValue({ workspace, path, }: {
+        workspace: string;
+        path: string;
+    }): CancelablePromise<any>;
     /**
      * does resource exists
      * @returns boolean does resource exists

package/gen/services/ResourceService.js

@@ -51,7 +51,7 @@ export class ResourceService {
     }
     /**
      * get resource
-     * @returns Resource resource deleted
+     * @returns Resource resource
      * @throws ApiError
      */
     static getResource({ workspace, path, }) {
@@ -64,6 +64,21 @@ export class ResourceService {
             },
         });
     }
+    /**
+     * get resource value
+     * @returns any resource value
+     * @throws ApiError
+     */
+    static getResourceValue({ workspace, path, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/resources/get_value/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
     /**
      * does resource exists
      * @returns boolean does resource exists

package/gen/services/ScriptService.d.ts

@@ -14,7 +14,7 @@ export declare class ScriptService {
             summary: string;
             app: string;
             approved: boolean;
-            kind: 'script' | 'failure' | 'trigger' | 'command';
+            kind: 'script' | 'failure' | 'trigger' | 'command' | 'approval';
             votes: number;
             views: number;
         }>;
@@ -27,6 +27,20 @@ export declare class ScriptService {
     static getHubScriptContentByPath({ path, }: {
         path: string;
     }): CancelablePromise<string>;
+    /**
+     * get full hub script by path
+     * @returns any script details
+     * @throws ApiError
+     */
+    static getHubScriptByPath({ path, }: {
+        path: string;
+    }): CancelablePromise<{
+        content: string;
+        lockfile?: string;
+        schema?: any;
+        language: 'deno' | 'python3' | 'go' | 'bash';
+        summary?: string;
+    }>;
     /**
      * list all available scripts
      * @returns Script All available scripts
@@ -120,8 +134,8 @@ export declare class ScriptService {
             schema?: any;
             is_template?: boolean;
             lock?: Array<string>;
-            language: 'python3' | 'deno' | 'go';
-            kind?: 'script' | 'failure' | 'trigger' | 'command';
+            language: 'python3' | 'deno' | 'go' | 'bash';
+            kind?: 'script' | 'failure' | 'trigger' | 'command' | 'approval';
         };
     }): CancelablePromise<string>;
     /**
@@ -146,6 +160,17 @@ export declare class ScriptService {
          */
         requestBody: string;
     }): CancelablePromise<MainArgSignature>;
+    /**
+     * inspect bash code to infer jsonschema of arguments
+     * @returns MainArgSignature parsed args
+     * @throws ApiError
+     */
+    static bashToJsonschema({ requestBody, }: {
+        /**
+         * bash code with the main function
+         */
+        requestBody: string;
+    }): CancelablePromise<MainArgSignature>;
     /**
      * inspect go code to infer jsonschema of arguments
      * @returns MainArgSignature parsed args

package/gen/services/ScriptService.js

@@ -26,6 +26,20 @@ export class ScriptService {
             },
         });
     }
+    /**
+     * get full hub script by path
+     * @returns any script details
+     * @throws ApiError
+     */
+    static getHubScriptByPath({ path, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/scripts/hub/get_full/{path}',
+            path: {
+                'path': path,
+            },
+        });
+    }
     /**
      * list all available scripts
      * @returns Script All available scripts
@@ -96,6 +110,19 @@ export class ScriptService {
             mediaType: 'application/json',
         });
     }
+    /**
+     * inspect bash code to infer jsonschema of arguments
+     * @returns MainArgSignature parsed args
+     * @throws ApiError
+     */
+    static bashToJsonschema({ requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/scripts/bash/tojsonschema',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
     /**
      * inspect go code to infer jsonschema of arguments
      * @returns MainArgSignature parsed args

package/gen/services/UserService.d.ts

@@ -20,6 +20,12 @@ export declare class UserService {
          */
         requestBody: Login;
     }): CancelablePromise<string>;
+    /**
+     * logout
+     * @returns string clear cookies and clear token (if applicable)
+     * @throws ApiError
+     */
+    static logout(): CancelablePromise<string>;
     /**
      * create user (require admin privilege)
      * @returns string user created
@@ -89,6 +95,14 @@ export declare class UserService {
             is_super_admin?: boolean;
         };
     }): CancelablePromise<string>;
+    /**
+     * global delete user (require super admin)
+     * @returns string user deleted
+     * @throws ApiError
+     */
+    static globalUserDelete({ email, }: {
+        email: string;
+    }): CancelablePromise<string>;
     /**
      * delete user (require admin privilege)
      * @returns string delete user
@@ -98,12 +112,6 @@ export declare class UserService {
         workspace: string;
         username: string;
     }): CancelablePromise<string>;
-    /**
-     * logout
-     * @returns string logout
-     * @throws ApiError
-     */
-    static logout(): CancelablePromise<string>;
     /**
      * get current user email (if logged in)
      * @returns string user email

package/gen/services/UserService.js

@@ -15,6 +15,17 @@ export class UserService {
             mediaType: 'application/json',
         });
     }
+    /**
+     * logout
+     * @returns string clear cookies and clear token (if applicable)
+     * @throws ApiError
+     */
+    static logout() {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/logout',
+        });
+    }
     /**
      * create user (require admin privilege)
      * @returns string user created
@@ -91,29 +102,32 @@ export class UserService {
         });
     }
     /**
-     * delete user (require admin privilege)
-     * @returns string delete user
+     * global delete user (require super admin)
+     * @returns string user deleted
      * @throws ApiError
      */
-    static deleteUser({ workspace, username, }) {
+    static globalUserDelete({ email, }) {
         return __request(OpenAPI, {
             method: 'DELETE',
-            url: '/w/{workspace}/users/delete/{username}',
+            url: '/users/delete/{email}',
             path: {
-                'workspace': workspace,
-                'username': username,
+                'email': email,
             },
         });
     }
     /**
-     * logout
-     * @returns string logout
+     * delete user (require admin privilege)
+     * @returns string delete user
      * @throws ApiError
      */
-    static logout() {
+    static deleteUser({ workspace, username, }) {
         return __request(OpenAPI, {
-            method: 'POST',
-            url: '/users/logout',
+            method: 'DELETE',
+            url: '/w/{workspace}/users/delete/{username}',
+            path: {
+                'workspace': workspace,
+                'username': username,
+            },
         });
     }
     /**

package/infer.d.ts

@@ -1,2 +1,2 @@
 import type { Schema } from './common.js';
-export declare function inferArgs(language: 'python3' | 'deno' | 'go', code: string, schema: Schema): Promise<void>;
+export declare function inferArgs(language: 'python3' | 'deno' | 'go' | 'bash', code: string, schema: Schema): Promise<void>;

package/infer.js

@@ -1,26 +1,40 @@
 import { ScriptService } from './gen';
+import { get, writable } from 'svelte/store';
+const loadSchemaLastRun = writable(undefined);
 export async function inferArgs(language, code, schema) {
+    let lastRun = get(loadSchemaLastRun);
     let inferedSchema;
-    if (code == '') {
-        code = ' ';
-    }
-    if (language == 'python3') {
-        inferedSchema = await ScriptService.pythonToJsonschema({
-            requestBody: code
-        });
-    }
-    else if (language == 'deno') {
-        inferedSchema = await ScriptService.denoToJsonschema({
-            requestBody: code
-        });
-    }
-    else if (language == 'go') {
-        inferedSchema = await ScriptService.goToJsonschema({
-            requestBody: code
-        });
+    if (lastRun && code == lastRun[0] && lastRun[1]) {
+        inferedSchema = lastRun[1];
     }
     else {
-        return;
+        if (code == '') {
+            code = ' ';
+        }
+        if (language == 'python3') {
+            inferedSchema = await ScriptService.pythonToJsonschema({
+                requestBody: code
+            });
+        }
+        else if (language == 'deno') {
+            inferedSchema = await ScriptService.denoToJsonschema({
+                requestBody: code
+            });
+        }
+        else if (language == 'go') {
+            inferedSchema = await ScriptService.goToJsonschema({
+                requestBody: code
+            });
+        }
+        else if (language == 'bash') {
+            inferedSchema = await ScriptService.bashToJsonschema({
+                requestBody: code
+            });
+        }
+        else {
+            return;
+        }
+        loadSchemaLastRun.set([code, inferedSchema]);
     }
     schema.required = [];
     const oldProperties = Object.assign({}, schema.properties);
@@ -99,6 +113,9 @@ function argSigToJsonSchemaType(t, oldS) {
             newS.items = { type: 'string' };
         }
     }
+    else {
+        newS.type = 'object';
+    }
     if (oldS.type != newS.type) {
         for (const prop of Object.getOwnPropertyNames(newS)) {
             if (prop != "description") {

package/logout.d.ts

@@ -1,2 +1,2 @@
-export declare function logoutWithRedirect(rd?: string): void;
+export declare function logoutWithRedirect(rd?: string): Promise<void>;
 export declare function logout(): Promise<void>;

package/logout.js

@@ -2,28 +2,26 @@ import { goto } from '$app/navigation';
 import { UserService } from './gen';
 import { clearStores } from './stores.js';
 import { sendUserToast } from './utils.js';
-function clearCookies() {
-    document.cookie.split(";").forEach(function (c) { document.cookie = c.replace(/^ +/, "").replace(/=.*/, "=;expires=" + new Date().toUTCString() + ";path=/"); });
-}
-export function logoutWithRedirect(rd) {
+export async function logoutWithRedirect(rd) {
+    await clearUser();
     if (rd?.split('?')[0] != '/user/login') {
         const error = document.cookie.includes('token')
             ? `error=${encodeURIComponent('You have been logged out because your session has expired.')}&`
             : '';
-        clearCookies();
         goto(`/user/login?${error}${rd ? 'rd=' + encodeURIComponent(rd) : ''}`, { replaceState: true });
     }
 }
 export async function logout() {
+    await clearUser();
+    goto(`/user/login`);
+    sendUserToast('you have been logged out');
+}
+async function clearUser() {
     try {
         clearStores();
         await UserService.logout();
-        clearCookies();
     }
     catch (error) {
         console.error(error);
-        clearCookies();
     }
-    goto(`/user/login`);
-    sendUserToast('you have been logged out');
 }