windmill-components 1.85.0 → 1.87.0

package/dist/gen/services/UserService.js

@@ -0,0 +1,372 @@
+import { OpenAPI } from '../core/OpenAPI';
+import { request as __request } from '../core/request';
+export class UserService {
+    /**
+     * login with password
+     * @returns string Successfully authenticated. The session ID is returned in a cookie named `token` and as plaintext response. Preferred method of authorization is through the bearer token. The cookie is only for browser convenience.
+     *
+     * @throws ApiError
+     */
+    static login({ requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/auth/login',
+            body: requestBody,
+            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
+     * @throws ApiError
+     */
+    static createUser({ workspace, requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/users/add',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * update user (require admin privilege)
+     * @returns string edited user
+     * @throws ApiError
+     */
+    static updateUser({ workspace, username, requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/users/update/{username}',
+            path: {
+                'workspace': workspace,
+                'username': username,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * is owner of path
+     * @returns boolean is owner
+     * @throws ApiError
+     */
+    static isOwnerOfPath({ workspace, path, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/users/is_owner/{path}',
+            path: {
+                'workspace': workspace,
+                'path': path,
+            },
+        });
+    }
+    /**
+     * set password
+     * @returns string password set
+     * @throws ApiError
+     */
+    static setPassword({ requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/setpassword',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * create user
+     * @returns string user created
+     * @throws ApiError
+     */
+    static createUserGlobally({ requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/create',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * global update user (require super admin)
+     * @returns string user updated
+     * @throws ApiError
+     */
+    static globalUserUpdate({ email, requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/update/{email}',
+            path: {
+                'email': email,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * global delete user (require super admin)
+     * @returns string user deleted
+     * @throws ApiError
+     */
+    static globalUserDelete({ email, }) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/users/delete/{email}',
+            path: {
+                'email': email,
+            },
+        });
+    }
+    /**
+     * delete user (require admin privilege)
+     * @returns string delete user
+     * @throws ApiError
+     */
+    static deleteUser({ workspace, username, }) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/w/{workspace}/users/delete/{username}',
+            path: {
+                'workspace': workspace,
+                'username': username,
+            },
+        });
+    }
+    /**
+     * get current user email (if logged in)
+     * @returns string user email
+     * @throws ApiError
+     */
+    static getCurrentEmail() {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/email',
+        });
+    }
+    /**
+     * get current usage outside of premium workspaces
+     * @returns number free usage
+     * @throws ApiError
+     */
+    static getUsage() {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/usage',
+        });
+    }
+    /**
+     * get current global whoami (if logged in)
+     * @returns GlobalUserInfo user email
+     * @throws ApiError
+     */
+    static globalWhoami() {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/whoami',
+        });
+    }
+    /**
+     * list all workspace invites
+     * @returns WorkspaceInvite list all workspace invites
+     * @throws ApiError
+     */
+    static listWorkspaceInvites() {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/list_invites',
+        });
+    }
+    /**
+     * whoami
+     * @returns User user
+     * @throws ApiError
+     */
+    static whoami({ workspace, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/users/whoami',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+    /**
+     * leave workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static leaveWorkspace({ workspace, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/users/leave_workspace',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+    /**
+     * accept invite to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static acceptInvite({ requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/accept_invite',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * decline invite to workspace
+     * @returns string status
+     * @throws ApiError
+     */
+    static declineInvite({ requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/decline_invite',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * whois
+     * @returns User user
+     * @throws ApiError
+     */
+    static whois({ workspace, username, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/users/whois/{username}',
+            path: {
+                'workspace': workspace,
+                'username': username,
+            },
+        });
+    }
+    /**
+     * list all users as super admin (require to be super amdin)
+     * @returns GlobalUserInfo user
+     * @throws ApiError
+     */
+    static listUsersAsSuperAdmin({ page, perPage, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/list_as_super_admin',
+            query: {
+                'page': page,
+                'per_page': perPage,
+            },
+        });
+    }
+    /**
+     * list users
+     * @returns User user
+     * @throws ApiError
+     */
+    static listUsers({ workspace, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/users/list',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+    /**
+     * list usernames
+     * @returns string user
+     * @throws ApiError
+     */
+    static listUsernames({ workspace, }) {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/users/list_usernames',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
+    /**
+     * create token
+     * @returns string token created
+     * @throws ApiError
+     */
+    static createToken({ requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/tokens/create',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * create token to impersonate a user (require superadmin)
+     * @returns string token created
+     * @throws ApiError
+     */
+    static createTokenImpersonate({ requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/users/tokens/impersonate',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * delete token
+     * @returns string delete token
+     * @throws ApiError
+     */
+    static deleteToken({ tokenPrefix, }) {
+        return __request(OpenAPI, {
+            method: 'DELETE',
+            url: '/users/tokens/delete/{token_prefix}',
+            path: {
+                'token_prefix': tokenPrefix,
+            },
+        });
+    }
+    /**
+     * list token
+     * @returns TruncatedToken truncated token
+     * @throws ApiError
+     */
+    static listTokens() {
+        return __request(OpenAPI, {
+            method: 'GET',
+            url: '/users/tokens/list',
+        });
+    }
+    /**
+     * login with oauth authorization flow
+     * @returns string Successfully authenticated. The session ID is returned in a cookie named `token` and as plaintext response. Preferred method of authorization is through the bearer token. The cookie is only for browser convenience.
+     *
+     * @throws ApiError
+     */
+    static loginWithOauth({ clientName, requestBody, }) {
+        return __request(OpenAPI, {
+            method: 'POST',
+            url: '/oauth/login_callback/{client_name}',
+            path: {
+                'client_name': clientName,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+}

package/dist/script_helpers.d.ts

@@ -0,0 +1,19 @@
+import type { Script } from './gen';
+import PYTHON_INIT_CODE from './init_scripts/python_init_code';
+import PYTHON_INIT_CODE_CLEAR from './init_scripts/python_init_code_clear';
+import PYTHON_INIT_CODE_TRIGGER from './init_scripts/python_init_code_trigger';
+import PYTHON_FAILURE_MODULE_CODE from './init_scripts/python_failure_module';
+export { PYTHON_INIT_CODE, PYTHON_INIT_CODE_CLEAR, PYTHON_INIT_CODE_TRIGGER, PYTHON_FAILURE_MODULE_CODE };
+export declare const DENO_INIT_CODE: string;
+export declare const GO_INIT_CODE = "package inner\n\nimport (\n\t\"fmt\"\n\t\"rsc.io/quote\"\n\t// wmill \"github.com/windmill-labs/windmill-go-client\"\n)\n\n// the main must return (interface{}, error)\n\nfunc main(x string, nested struct {\n\tFoo string `json:\"foo\"`\n}) (interface{}, error) {\n\tfmt.Println(\"Hello, World\")\n\tfmt.Println(nested.Foo)\n\tfmt.Println(quote.Opt())\n\t// v, _ := wmill.GetVariable(\"f/examples/secret\")\n\treturn x, nil\n}\n";
+export declare const GO_FAILURE_MODULE_CODE = "package inner\n\nimport (\n\t\"fmt\"\n  \"os\"\n)\n\n// connect the error parameter to 'previous_result.error'\n\nfunc main(message string, name string) (interface{}, error) {\n\tfmt.Println(message)\n\tfmt.Println(name)\n\tfmt.Println(\"flow id that failed\", os.Getenv(\"WM_FLOW_JOB_ID\"))\n  return message, nil\n}\n";
+export declare const DENO_INIT_CODE_CLEAR: string;
+export declare const DENO_FAILURE_MODULE_CODE = "// flow is considered recovered and a success unless an exception is thrown\n\nexport async function main(message: string, name: string) {\n  const flow_id = Deno.env.get(\"WM_FLOW_JOB_ID\")\n  console.log(\"message\", message)\n  console.log(\"name\",name)\n  return { message, flow_id }\n}\n";
+export declare const POSTGRES_INIT_CODE: string;
+export declare const MYSQL_INIT_CODE: string;
+export declare const BASH_INIT_CODE = "# arguments of the form X=\"$I\" are parsed as parameters X of type string\nmsg=\"$1\"\ndflt=\"${2:-default value}\"\n\n# the last line of the stdout is the return value\necho \"Hello $msg\"\n";
+export declare const DENO_INIT_CODE_TRIGGER: string;
+export declare const GO_INIT_CODE_TRIGGER = "package inner\n\nimport (\n\twmill \"github.com/windmill-labs/windmill-go-client\"\n)\n\nfunc main() (interface{}, error) {\n\n\t// A common trigger script would follow this pattern:\n\t// 1. Get the last saved state\n\tstate, _ := wmill.GetState()\n\t// 2. Get the actual state from the external service\n\t// newState := ...\n\t// 3. Compare the two states and update the internal state\n\twmill.SetState(4)\n\t// 4. Return the new rows\n\n\treturn state, nil\n\n\t// In subsequent scripts, you may refer to each row/value returned by the trigger script using\n\t// 'flow_input.iter.value'\n}\n";
+export declare const DENO_INIT_CODE_APPROVAL = "import * as wmill from \"https://deno.land/x/windmill@v1.41.0/mod.ts\"\n\nexport async function main(approver?: string) {\n  return wmill.getResumeEndpoints(approver)\n}";
+export declare function isInitialCode(content: string): boolean;
+export declare function initialCode(language: 'deno' | 'python3' | 'go' | 'bash', kind: Script.kind, subkind: 'pgsql' | 'mysql' | 'flow' | 'script' | undefined): string;

package/dist/script_helpers.js

@@ -0,0 +1,237 @@
+import PYTHON_INIT_CODE from './init_scripts/python_init_code';
+import PYTHON_INIT_CODE_CLEAR from './init_scripts/python_init_code_clear';
+import PYTHON_INIT_CODE_TRIGGER from './init_scripts/python_init_code_trigger';
+import PYTHON_FAILURE_MODULE_CODE from './init_scripts/python_failure_module';
+export { PYTHON_INIT_CODE, PYTHON_INIT_CODE_CLEAR, PYTHON_INIT_CODE_TRIGGER, PYTHON_FAILURE_MODULE_CODE };
+export const DENO_INIT_CODE = `// Ctrl/CMD+. to cache dependencies on imports hover, Ctrl/CMD+S to format.
+
+// import { toWords } from "npm:number-to-words@1"
+// import * as wmill from "https://deno.land/x/windmill@v${__pkg__.version}/mod.ts"
+
+export async function main(
+  a: number,
+  b: "my" | "enum",
+  //c: Resource<'postgresql'>,
+  d = "inferred type string from default arg",
+  e = { nested: "object" },
+  //e: wmill.Base64
+) {
+  // let x = await wmill.getVariable('u/user/foo')
+  return { foo: a };
+}
+`;
+export const GO_INIT_CODE = `package inner
+
+import (
+	"fmt"
+	"rsc.io/quote"
+	// wmill "github.com/windmill-labs/windmill-go-client"
+)
+
+// the main must return (interface{}, error)
+
+func main(x string, nested struct {
+	Foo string \`json:"foo"\`
+}) (interface{}, error) {
+	fmt.Println("Hello, World")
+	fmt.Println(nested.Foo)
+	fmt.Println(quote.Opt())
+	// v, _ := wmill.GetVariable("f/examples/secret")
+	return x, nil
+}
+`;
+export const GO_FAILURE_MODULE_CODE = `package inner
+
+import (
+	"fmt"
+  "os"
+)
+
+// connect the error parameter to 'previous_result.error'
+
+func main(message string, name string) (interface{}, error) {
+	fmt.Println(message)
+	fmt.Println(name)
+	fmt.Println("flow id that failed", os.Getenv("WM_FLOW_JOB_ID"))
+  return message, nil
+}
+`;
+export const DENO_INIT_CODE_CLEAR = `// import * as wmill from "https://deno.land/x/windmill@v${__pkg__.version}/mod.ts"
+
+export async function main(x: string) {
+  return x
+}
+`;
+export const DENO_FAILURE_MODULE_CODE = `// flow is considered recovered and a success unless an exception is thrown
+
+export async function main(message: string, name: string) {
+  const flow_id = Deno.env.get("WM_FLOW_JOB_ID")
+  console.log("message", message)
+  console.log("name",name)
+  return { message, flow_id }
+}
+`;
+export const POSTGRES_INIT_CODE = `import {
+  pgSql,
+  type Resource,
+} from "https://deno.land/x/windmill@v${__pkg__.version}/mod.ts";
+
+//PG parameterized statement. No SQL injection is possible.
+export async function main(
+  db: Resource<"postgresql"> = "$res:g/all/demodb",
+  key: number,
+  value: string,
+) {
+  const query = await pgSql(
+    db,
+  )\`INSERT INTO demo VALUES (\${key}, \${value}) RETURNING *\`;
+  return query.rows;
+}`;
+export const MYSQL_INIT_CODE = `import {
+  mySql,
+  type Resource
+} from "https://deno.land/x/windmill@v${__pkg__.version}/mysql.ts";
+
+// MySQL parameterized statement. No SQL injection is possible.
+export async function main(
+  db: Resource<"mysql">,
+  key: number,
+  value: string,
+) {
+  const query = await mySql(
+    db
+  )\`INSERT INTO demo VALUES (\${key}, \${value})\`;
+  return query.rows;
+}`;
+export const BASH_INIT_CODE = `# arguments of the form X="$I" are parsed as parameters X of type string
+msg="$1"
+dflt="\${2:-default value}"
+
+# the last line of the stdout is the return value
+echo "Hello $msg"
+`;
+export const DENO_INIT_CODE_TRIGGER = `import * as wmill from "https://deno.land/x/windmill@v${__pkg__.version}/mod.ts"
+
+export async function main() {
+
+  // A common trigger script would follow this pattern:
+  // 1. Get the last saved state
+  // const state = await wmill.getState()
+  // 2. Get the actual state from the external service
+  // const newState = await (await fetch('https://hacker-news.firebaseio.com/v0/topstories.json')).json()
+  // 3. Compare the two states and update the internal state
+  // await wmill.setState(newState)
+  // 4. Return the new rows
+  // return range from (state to newState)
+
+  return [1,2,3]
+
+  // In subsequent scripts, you may refer to each row/value returned by the trigger script using
+  // 'flow_input.iter.value'
+}
+`;
+export const GO_INIT_CODE_TRIGGER = `package inner
+
+import (
+	wmill "github.com/windmill-labs/windmill-go-client"
+)
+
+func main() (interface{}, error) {
+
+	// A common trigger script would follow this pattern:
+	// 1. Get the last saved state
+	state, _ := wmill.GetState()
+	// 2. Get the actual state from the external service
+	// newState := ...
+	// 3. Compare the two states and update the internal state
+	wmill.SetState(4)
+	// 4. Return the new rows
+
+	return state, nil
+
+	// In subsequent scripts, you may refer to each row/value returned by the trigger script using
+	// 'flow_input.iter.value'
+}
+`;
+export const DENO_INIT_CODE_APPROVAL = `import * as wmill from "https://deno.land/x/windmill@v1.41.0/mod.ts"
+
+export async function main(approver?: string) {
+  return wmill.getResumeEndpoints(approver)
+}`;
+const ALL_INITIAL_CODE = [
+    PYTHON_INIT_CODE,
+    PYTHON_INIT_CODE_TRIGGER,
+    DENO_INIT_CODE,
+    POSTGRES_INIT_CODE,
+    DENO_INIT_CODE_TRIGGER,
+    DENO_INIT_CODE_CLEAR,
+    PYTHON_INIT_CODE_CLEAR,
+    DENO_INIT_CODE_APPROVAL,
+    DENO_FAILURE_MODULE_CODE
+];
+export function isInitialCode(content) {
+    for (const code of ALL_INITIAL_CODE) {
+        if (content === code) {
+            return true;
+        }
+    }
+    return false;
+}
+export function initialCode(language, kind, subkind) {
+    if (language === 'deno') {
+        if (kind === 'trigger') {
+            return DENO_INIT_CODE_TRIGGER;
+        }
+        else if (kind === 'script') {
+            if (subkind === 'flow') {
+                return DENO_INIT_CODE_CLEAR;
+            }
+            else if (subkind === 'pgsql') {
+                return POSTGRES_INIT_CODE;
+            }
+            else if (subkind === 'mysql') {
+                return MYSQL_INIT_CODE;
+            }
+            else {
+                return DENO_INIT_CODE;
+            }
+        }
+        else if (kind === 'failure') {
+            return DENO_FAILURE_MODULE_CODE;
+        }
+        else if (kind === 'approval') {
+            return DENO_INIT_CODE_APPROVAL;
+        }
+        else {
+            return DENO_INIT_CODE;
+        }
+    }
+    else if (language === 'python3') {
+        if (subkind === 'flow') {
+            return PYTHON_INIT_CODE_CLEAR;
+        }
+        else if (kind === 'failure') {
+            return PYTHON_FAILURE_MODULE_CODE;
+        }
+        else if (kind === 'trigger') {
+            return PYTHON_INIT_CODE_TRIGGER;
+        }
+        else {
+            return PYTHON_INIT_CODE;
+        }
+    }
+    else if (language == 'bash') {
+        return BASH_INIT_CODE;
+    }
+    else {
+        if (kind === 'failure') {
+            return GO_FAILURE_MODULE_CODE;
+        }
+        else if (kind === 'trigger') {
+            return GO_INIT_CODE_TRIGGER;
+        }
+        else {
+            return GO_INIT_CODE;
+        }
+    }
+}

package/dist/stores.d.ts

@@ -0,0 +1,42 @@
+import { type Readable } from 'svelte/store';
+import type { UserWorkspaceList } from './gen/models/UserWorkspaceList.js';
+import { type TokenResponse } from './gen';
+export interface UserExt {
+    email: string;
+    username: string;
+    is_admin: boolean;
+    is_super_admin: boolean;
+    operator: boolean;
+    created_at: string;
+    groups: string[];
+    pgroups: string[];
+    folders: string[];
+    folders_owners: string[];
+}
+export declare const usageStore: import("svelte/store").Writable<number>;
+export declare const runFormStore: import("svelte/store").Writable<any>;
+export declare const oauthStore: import("svelte/store").Writable<TokenResponse | undefined>;
+export declare const userStore: import("svelte/store").Writable<UserExt | undefined>;
+export declare const workspaceStore: import("svelte/store").Writable<string | undefined>;
+export declare const premiumStore: import("svelte/store").Writable<{
+    premium: boolean;
+    usage?: number | undefined;
+}>;
+export declare const starStore: import("svelte/store").Writable<number>;
+export declare const usersWorkspaceStore: import("svelte/store").Writable<UserWorkspaceList | undefined>;
+export declare const superadmin: import("svelte/store").Writable<false | String | undefined>;
+export declare const userWorkspaces: Readable<Array<{
+    id: string;
+    name: string;
+    username: string;
+}>>;
+export declare const hubScripts: import("svelte/store").Writable<{
+    path: string;
+    summary: string;
+    approved: boolean;
+    kind: string;
+    app: string;
+    ask_id: number;
+}[] | undefined>;
+export declare function switchWorkspace(workspace: string | undefined): void;
+export declare function clearStores(): void;