windmill-client 0.2.1 → 0.3.2

package/dist/{services → src/services}/ScriptService.js

@@ -102,58 +102,6 @@ class ScriptService {
             mediaType: 'application/json',
         });
     }
-    /**
-     * inspect python code to infer jsonschema of arguments
-     * @returns MainArgSignature parsed args
-     * @throws ApiError
-     */
-    static pythonToJsonschema({ requestBody, }) {
-        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
-            method: 'POST',
-            url: '/scripts/python/tojsonschema',
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * inspect deno code to infer jsonschema of arguments
-     * @returns MainArgSignature parsed args
-     * @throws ApiError
-     */
-    static denoToJsonschema({ requestBody, }) {
-        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
-            method: 'POST',
-            url: '/scripts/deno/tojsonschema',
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * inspect bash code to infer jsonschema of arguments
-     * @returns MainArgSignature parsed args
-     * @throws ApiError
-     */
-    static bashToJsonschema({ requestBody, }) {
-        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
-            method: 'POST',
-            url: '/scripts/bash/tojsonschema',
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
-    /**
-     * inspect go code to infer jsonschema of arguments
-     * @returns MainArgSignature parsed args
-     * @throws ApiError
-     */
-    static goToJsonschema({ requestBody, }) {
-        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
-            method: 'POST',
-            url: '/scripts/go/tojsonschema',
-            body: requestBody,
-            mediaType: 'application/json',
-        });
-    }
     /**
      * archive script by path
      * @returns string script archived

package/dist/{services → src/services}/SettingsService.d.ts

@@ -6,6 +6,18 @@ export declare class SettingsService {
      * @throws ApiError
      */
     static backendVersion(): CancelablePromise<string>;
+    /**
+     * is backend up to date
+     * @returns string is backend up to date
+     * @throws ApiError
+     */
+    static backendUptodate(): CancelablePromise<string>;
+    /**
+     * get license id
+     * @returns string get license id (empty if not ee)
+     * @throws ApiError
+     */
+    static getLicenseId(): CancelablePromise<string>;
     /**
      * get openapi yaml spec
      * @returns string openapi yaml file content

package/dist/{services → src/services}/SettingsService.js

@@ -15,6 +15,28 @@ class SettingsService {
             url: '/version',
         });
     }
+    /**
+     * is backend up to date
+     * @returns string is backend up to date
+     * @throws ApiError
+     */
+    static backendUptodate() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/uptodate',
+        });
+    }
+    /**
+     * get license id
+     * @returns string get license id (empty if not ee)
+     * @throws ApiError
+     */
+    static getLicenseId() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/ee_license',
+        });
+    }
     /**
      * get openapi yaml spec
      * @returns string openapi yaml file content

package/dist/{services → src/services}/UserService.d.ts

@@ -134,6 +134,20 @@ export declare class UserService {
      * @throws ApiError
      */
     static getUsage(): CancelablePromise<number>;
+    /**
+     * get all runnables in every workspace
+     * @returns any free all runnables
+     * @throws ApiError
+     */
+    static getRunnable(): CancelablePromise<{
+        workspace: string;
+        endpoint_async: string;
+        endpoint_sync: string;
+        endpoint_openai_sync: string;
+        summary: string;
+        description?: string;
+        kind: string;
+    }>;
     /**
      * get current global whoami (if logged in)
      * @returns GlobalUserInfo user email
@@ -198,6 +212,14 @@ export declare class UserService {
         workspace: string;
         username: string;
     }): CancelablePromise<User>;
+    /**
+     * exists email
+     * @returns boolean user
+     * @throws ApiError
+     */
+    static existsEmail({ email, }: {
+        email: string;
+    }): CancelablePromise<boolean>;
     /**
      * list all users as super admin (require to be super amdin)
      * @returns GlobalUserInfo user

package/dist/{services → src/services}/UserService.js

@@ -170,6 +170,17 @@ class UserService {
             url: '/users/usage',
         });
     }
+    /**
+     * get all runnables in every workspace
+     * @returns any free all runnables
+     * @throws ApiError
+     */
+    static getRunnable() {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/users/all_runnables',
+        });
+    }
     /**
      * get current global whoami (if logged in)
      * @returns GlobalUserInfo user email
@@ -261,6 +272,20 @@ class UserService {
             },
         });
     }
+    /**
+     * exists email
+     * @returns boolean user
+     * @throws ApiError
+     */
+    static existsEmail({ email, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/users/exists/{email}',
+            path: {
+                'email': email,
+            },
+        });
+    }
     /**
      * list all users as super admin (require to be super amdin)
      * @returns GlobalUserInfo user

package/{src → dist/src}/services/VariableService.d.ts

@@ -17,6 +17,18 @@ export declare class VariableService {
         requestBody: CreateVariable;
         alreadyEncrypted?: boolean;
     }): CancelablePromise<string>;
+    /**
+     * encrypt value
+     * @returns string encrypted value
+     * @throws ApiError
+     */
+    static encryptValue({ workspace, requestBody, }: {
+        workspace: string;
+        /**
+         * new variable
+         */
+        requestBody: string;
+    }): CancelablePromise<string>;
     /**
      * delete variable
      * @returns string variable deleted

package/dist/{services → src/services}/VariableService.js

@@ -23,6 +23,22 @@ class VariableService {
             mediaType: 'application/json',
         });
     }
+    /**
+     * encrypt value
+     * @returns string encrypted value
+     * @throws ApiError
+     */
+    static encryptValue({ workspace, requestBody, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/variables/encrypt',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
     /**
      * delete variable
      * @returns string variable deleted

package/dist/{services → src/services}/WorkspaceService.d.ts

@@ -170,6 +170,17 @@ export declare class WorkspaceService {
         plan?: string;
         customer_id?: string;
         webhook?: string;
+        deploy_to?: string;
+    }>;
+    /**
+     * get deploy to
+     * @returns any status
+     * @throws ApiError
+     */
+    static getDeployTo({ workspace, }: {
+        workspace: string;
+    }): CancelablePromise<{
+        deploy_to?: string;
     }>;
     /**
      * get premium info
@@ -196,6 +207,17 @@ export declare class WorkspaceService {
             slack_command_script?: string;
         };
     }): CancelablePromise<string>;
+    /**
+     * edit deploy to
+     * @returns string status
+     * @throws ApiError
+     */
+    static editDeployTo({ workspace, requestBody, }: {
+        workspace: string;
+        requestBody: {
+            deploy_to?: string;
+        };
+    }): CancelablePromise<string>;
     /**
      * edit auto invite
      * @returns string status

package/dist/{services → src/services}/WorkspaceService.js

@@ -209,6 +209,20 @@ class WorkspaceService {
             },
         });
     }
+    /**
+     * get deploy to
+     * @returns any status
+     * @throws ApiError
+     */
+    static getDeployTo({ workspace, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'GET',
+            url: '/w/{workspace}/workspaces/get_deploy_to',
+            path: {
+                'workspace': workspace,
+            },
+        });
+    }
     /**
      * get premium info
      * @returns any status
@@ -239,6 +253,22 @@ class WorkspaceService {
             mediaType: 'application/json',
         });
     }
+    /**
+     * edit deploy to
+     * @returns string status
+     * @throws ApiError
+     */
+    static editDeployTo({ workspace, requestBody, }) {
+        return (0, request_1.request)(OpenAPI_1.OpenAPI, {
+            method: 'POST',
+            url: '/w/{workspace}/workspaces/edit_deploy_to',
+            path: {
+                'workspace': workspace,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
     /**
      * edit auto invite
      * @returns string status

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "windmill-client",
   "description": "Windmill SDK client for browsers and Node.js",
-  "version": "0.2.1",
+  "version": "0.3.2",
   "author": "Ruben Fiszel",
   "license": "Apache 2.0",
   "dependencies": {},

package/publish.sh

@@ -0,0 +1,3 @@
+./build.sh
+tsc
+npm publish

package/src/client.ts

@@ -0,0 +1,376 @@
+import { JobService, ResourceService, VariableService } from "./index.ts";
+import { OpenAPI } from "./index.ts";
+
+export {
+  AdminService,
+  AuditService,
+  FlowService,
+  GranularAclService,
+  GroupService,
+  JobService,
+  ResourceService,
+  VariableService,
+  ScriptService,
+  ScheduleService,
+  SettingsService,
+  UserService,
+  WorkspaceService,
+} from "./index.ts";
+
+export type Sql = string;
+export type Email = string;
+export type Base64 = string;
+export type Resource<S extends string> = any;
+
+export const SHARED_FOLDER = "/shared";
+
+export function setClient(token?: string, baseUrl?: string) {
+  if (baseUrl === undefined) {
+    baseUrl = getEnv("BASE_INTERNAL_URL") ??
+      getEnv("BASE_URL") ??
+      "http://localhost:8000"
+  }
+  if (token === undefined) {
+    baseUrl = getEnv("WM_TOKEN") ?? "no_token",
+  }
+  OpenAPI.WITH_CREDENTIALS = true;
+  OpenAPI.TOKEN = token;
+  OpenAPI.BASE = baseUrl + "/api";
+}
+
+const getEnv = (key: string) => {
+  if (typeof window === 'undefined') {
+    // node
+    return process.env[key]
+  }
+  // browser
+  return window.process.env[key]
+}
+
+
+
+/**
+ * Create a client configuration from env variables
+ * @returns client configuration
+ */
+export function getWorkspace(): string {
+  return getEnv("WM_WORKSPACE") ?? "no_workspace";
+}
+
+/**
+ * Get a resource value by path
+ * @param path path of the resource,  default to internal state path
+ * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
+ * @returns resource value
+ */
+export async function getResource(
+  path?: string,
+  undefinedIfEmpty?: boolean
+): Promise<any> {
+  const workspace = getWorkspace();
+  path = path ?? getStatePath();
+  try {
+    const resource = await ResourceService.getResource({ workspace, path });
+    return await _transformLeaf(resource.value);
+  } catch (e: any) {
+    if (undefinedIfEmpty && e.status === 404) {
+      return undefined;
+    } else {
+      throw Error(`Resource not found at ${path} or not visible to you`);
+    }
+  }
+}
+
+/**
+ * Resolve a resource value in case the default value was picked because the input payload was undefined
+ * @param obj resource value or path of the resource under the format `$res:path`
+ * @returns resource value
+ */
+export async function resolveDefaultResource(obj: any): Promise<any> {
+  if (typeof obj === "string" && obj.startsWith("$res:")) {
+    return await getResource(obj.substring(5), true);
+  } else {
+    return obj;
+  }
+}
+
+/**
+ * Get the full resource value by path
+ * @param path path of the resource,  default to internal state path
+ * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
+ * @returns full resource
+ */
+export async function getFullResource(
+  path?: string,
+  undefinedIfEmpty?: boolean
+): Promise<any> {
+  const workspace = getWorkspace();
+  path = path ?? getStatePath();
+  try {
+    const resource = await ResourceService.getResource({ workspace, path });
+    const value = await _transformLeaf(resource.value);
+    return { ...resource, value };
+  } catch (e: any) {
+    if (undefinedIfEmpty && e.status === 404) {
+      return undefined;
+    } else {
+      throw Error(`Resource not found at ${path} or not visible to you`);
+    }
+  }
+}
+
+export function getStatePath(): string {
+  const state_path = getEnv("WM_STATE_PATH");
+  if (state_path === undefined) {
+    throw Error("State path not set");
+  }
+  return state_path;
+}
+
+/**
+ * Set a resource value by path
+ * @param path path of the resource to set, default to state path
+ * @param value new value of the resource to set
+ * @param initializeToTypeIfNotExist if the resource does not exist, initialize it with this type
+ */
+export async function setResource(
+  value: any,
+  path?: string,
+  initializeToTypeIfNotExist?: string
+): Promise<void> {
+  path = path ?? getStatePath();
+  const workspace = getWorkspace();
+  if (await ResourceService.existsResource({ workspace, path })) {
+    await ResourceService.updateResourceValue({
+      workspace,
+      path,
+      requestBody: { value },
+    });
+  } else if (initializeToTypeIfNotExist) {
+    await ResourceService.createResource({
+      workspace,
+      requestBody: { path, value, resource_type: initializeToTypeIfNotExist },
+    });
+  } else {
+    throw Error(
+      `Resource at path ${path} does not exist and no type was provided to initialize it`
+    );
+  }
+}
+
+/**
+ * Set the state
+ * @param state state to set
+ * @deprecated use setState instead
+ */
+export async function setInternalState(state: any): Promise<void> {
+  await setResource(state, undefined, "state");
+}
+
+/**
+ * Set the state
+ * @param state state to set
+ */
+export async function setState(state: any): Promise<void> {
+  await setResource(state, undefined, "state");
+}
+
+// /**
+//  * Set the shared state
+//  * @param state state to set
+//  */
+// export async function setSharedState(
+//   state: any,
+//   path = "state.json"
+// ): Promise<void> {
+//   await Deno.writeTextFile(SHARED_FOLDER + "/" + path, JSON.stringify(state));
+// }
+
+// /**
+//  * Get the shared state
+//  * @param state state to set
+//  */
+// export async function getSharedState(path = "state.json"): Promise<any> {
+//   return JSON.parse(await Deno.readTextFile(SHARED_FOLDER + "/" + path));
+// }
+
+/**
+ * Get the internal state
+ * @deprecated use getState instead
+ */
+export async function getInternalState(): Promise<any> {
+  return await getResource(getStatePath(), true);
+}
+
+/**
+ * Get the state shared across executions
+ */
+export async function getState(): Promise<any> {
+  return await getResource(getStatePath(), true);
+}
+
+/**
+ * Get a variable by path
+ * @param path path of the variable
+ * @returns variable value
+ */
+export async function getVariable(path: string): Promise<string | undefined> {
+  const workspace = getWorkspace();
+  try {
+    const variable = await VariableService.getVariable({ workspace, path });
+    return variable.value;
+  } catch (e: any) {
+    throw Error(`Variable not found at ${path} or not visible to you`);
+  }
+}
+
+/**
+ * Set a variable by path, create if not exist
+ * @param path path of the variable
+ * @param value value of the variable
+ * @param isSecretIfNotExist if the variable does not exist, create it as secret or not (default: false)
+ * @param descriptionIfNotExist if the variable does not exist, create it with this description (default: "")
+ */
+export async function setVariable(
+  path: string,
+  value: string,
+  isSecretIfNotExist?: boolean,
+  descriptionIfNotExist?: string
+): Promise<void> {
+  const workspace = getWorkspace();
+  if (await VariableService.existsVariable({ workspace, path })) {
+    await VariableService.updateVariable({
+      workspace,
+      path,
+      requestBody: { value },
+    });
+  } else {
+    await VariableService.createVariable({
+      workspace,
+      requestBody: {
+        path,
+        value,
+        is_secret: isSecretIfNotExist ?? false,
+        description: descriptionIfNotExist ?? "",
+      },
+    });
+  }
+}
+
+async function transformLeaves(d: {
+  [key: string]: any;
+}): Promise<{ [key: string]: any }> {
+  for (const k in d) {
+    d[k] = await _transformLeaf(d[k]);
+  }
+  return d;
+}
+
+const VAR_RESOURCE_PREFIX = "$var:";
+const RES_RESOURCE_PREFIX = "$res:";
+async function _transformLeaf(v: any): Promise<any> {
+  if (typeof v === "object") {
+    return transformLeaves(v);
+  } else if (typeof v === "string" && v.startsWith(VAR_RESOURCE_PREFIX)) {
+    const varName = v.substring(VAR_RESOURCE_PREFIX.length);
+    return await getVariable(varName);
+  } else if (typeof v === "string" && v.startsWith(RES_RESOURCE_PREFIX)) {
+    const resName = v.substring(RES_RESOURCE_PREFIX.length);
+    return await getResource(resName);
+  } else {
+    return v;
+  }
+}
+
+export async function databaseUrlFromResource(path: string): Promise<string> {
+  const resource = await getResource(path);
+  return `postgresql://${resource.user}:${resource.password}@${resource.host}:${resource.port}/${resource.dbname}?sslmode=${resource.sslmode}`;
+}
+
+// /**
+//  * Get URLs needed for resuming a flow after this step
+//  * @param approver approver name
+//  * @returns approval page UI URL, resume and cancel API URLs for resumeing the flow
+//  */
+// export async function getResumeUrls(approver?: string): Promise<{
+//   approvalPage: string;
+//   resume: string;
+//   cancel: string;
+// }> {
+//   const nonce = Math.floor(Math.random() * 4294967295);
+//   const workspace = getWorkspace();
+//   return await JobService.getResumeUrls({
+//     workspace,
+//     resumeId: nonce,
+//     approver,
+//     id: process.env.get("WM_JOB_ID") ?? "NO_JOB_ID",
+//   });
+// }
+
+/**
+ * @deprecated use getResumeUrls instead
+ */
+export function getResumeEndpoints(approver?: string): Promise<{
+  approvalPage: string;
+  resume: string;
+  cancel: string;
+}> {
+  return getResumeUrls(approver);
+}
+
+export function base64ToUint8Array(data: string): Uint8Array {
+  return Uint8Array.from(atob(data), (c) => c.charCodeAt(0));
+}
+
+export function uint8ArrayToBase64(arrayBuffer: Uint8Array): string {
+  let base64 = "";
+  const encodings =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+  const bytes = new Uint8Array(arrayBuffer);
+  const byteLength = bytes.byteLength;
+  const byteRemainder = byteLength % 3;
+  const mainLength = byteLength - byteRemainder;
+
+  let a, b, c, d;
+  let chunk;
+
+  // Main loop deals with bytes in chunks of 3
+  for (let i = 0; i < mainLength; i = i + 3) {
+    // Combine the three bytes into a single integer
+    chunk = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+
+    // Use bitmasks to extract 6-bit segments from the triplet
+    a = (chunk & 16515072) >> 18; // 16515072 = (2^6 - 1) << 18
+    b = (chunk & 258048) >> 12; // 258048   = (2^6 - 1) << 12
+    c = (chunk & 4032) >> 6; // 4032     = (2^6 - 1) << 6
+    d = chunk & 63; // 63       = 2^6 - 1
+
+    // Convert the raw binary segments to the appropriate ASCII encoding
+    base64 += encodings[a] + encodings[b] + encodings[c] + encodings[d];
+  }
+
+  // Deal with the remaining bytes and padding
+  if (byteRemainder == 1) {
+    chunk = bytes[mainLength];
+
+    a = (chunk & 252) >> 2; // 252 = (2^6 - 1) << 2
+
+    // Set the 4 least significant bits to zero
+    b = (chunk & 3) << 4; // 3   = 2^2 - 1
+
+    base64 += encodings[a] + encodings[b] + "==";
+  } else if (byteRemainder == 2) {
+    chunk = (bytes[mainLength] << 8) | bytes[mainLength + 1];
+
+    a = (chunk & 64512) >> 10; // 64512 = (2^6 - 1) << 10
+    b = (chunk & 1008) >> 4; // 1008  = (2^6 - 1) << 4
+
+    // Set the 2 least significant bits to zero
+    c = (chunk & 15) << 2; // 15    = 2^4 - 1
+
+    base64 += encodings[a] + encodings[b] + encodings[c] + "=";
+  }
+
+  return base64;
+}

package/src/core/ApiError.ts

@@ -1,3 +1,4 @@
+/* generated using openapi-typescript-codegen -- do no edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */