windmill-client 0.3.11 → 0.3.13

package/dist/src/client.js

@@ -0,0 +1,301 @@
+import { ResourceService, VariableService } from "./index.js";
+import { OpenAPI } from "./index.js";
+export { AdminService, AuditService, FlowService, GranularAclService, GroupService, JobService, ResourceService, VariableService, ScriptService, ScheduleService, SettingsService, UserService, WorkspaceService, } from "./index.js";
+export const SHARED_FOLDER = "/shared";
+export function setClient(token, baseUrl) {
+    if (baseUrl === undefined) {
+        baseUrl =
+            getEnv("BASE_INTERNAL_URL") ??
+                getEnv("BASE_URL") ??
+                "http://localhost:8000";
+    }
+    if (token === undefined) {
+        token = getEnv("WM_TOKEN") ?? "no_token";
+    }
+    OpenAPI.WITH_CREDENTIALS = true;
+    OpenAPI.TOKEN = token;
+    OpenAPI.BASE = baseUrl + "/api";
+}
+const getEnv = (key) => {
+    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() {
+    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, undefinedIfEmpty) {
+    const workspace = getWorkspace();
+    path = path ?? getStatePath();
+    try {
+        const resource = await ResourceService.getResource({ workspace, path });
+        return await _transformLeaf(resource.value);
+    }
+    catch (e) {
+        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) {
+    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, undefinedIfEmpty) {
+    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) {
+        if (undefinedIfEmpty && e.status === 404) {
+            return undefined;
+        }
+        else {
+            throw Error(`Resource not found at ${path} or not visible to you`);
+        }
+    }
+}
+export function getStatePath() {
+    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, path, initializeToTypeIfNotExist) {
+    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) {
+    await setResource(state, undefined, "state");
+}
+/**
+ * Set the state
+ * @param state state to set
+ */
+export async function setState(state) {
+    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() {
+    return await getResource(getStatePath(), true);
+}
+/**
+ * Get the state shared across executions
+ */
+export async function getState() {
+    return await getResource(getStatePath(), true);
+}
+/**
+ * Get a variable by path
+ * @param path path of the variable
+ * @returns variable value
+ */
+export async function getVariable(path) {
+    const workspace = getWorkspace();
+    try {
+        const variable = await VariableService.getVariable({ workspace, path });
+        return variable.value;
+    }
+    catch (e) {
+        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, value, isSecretIfNotExist, descriptionIfNotExist) {
+    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) {
+    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) {
+    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) {
+    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",
+//   });
+// }
+export function base64ToUint8Array(data) {
+    return Uint8Array.from(atob(data), (c) => c.charCodeAt(0));
+}
+export function uint8ArrayToBase64(arrayBuffer) {
+    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/dist/src/core/ApiError.d.ts

@@ -0,0 +1,10 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+export declare class ApiError extends Error {
+    readonly url: string;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+    readonly request: ApiRequestOptions;
+    constructor(request: ApiRequestOptions, response: ApiResult, message: string);
+}

package/dist/src/core/ApiError.js

@@ -0,0 +1,11 @@
+export class ApiError extends Error {
+    constructor(request, response, message) {
+        super(message);
+        this.name = 'ApiError';
+        this.url = response.url;
+        this.status = response.status;
+        this.statusText = response.statusText;
+        this.body = response.body;
+        this.request = request;
+    }
+}

package/dist/src/core/ApiRequestOptions.d.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+    readonly url: string;
+    readonly path?: Record<string, any>;
+    readonly cookies?: Record<string, any>;
+    readonly headers?: Record<string, any>;
+    readonly query?: Record<string, any>;
+    readonly formData?: Record<string, any>;
+    readonly body?: any;
+    readonly mediaType?: string;
+    readonly responseHeader?: string;
+    readonly errors?: Record<number, string>;
+};

package/dist/src/core/ApiRequestOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/ApiResult.d.ts

@@ -0,0 +1,7 @@
+export type ApiResult = {
+    readonly url: string;
+    readonly ok: boolean;
+    readonly status: number;
+    readonly statusText: string;
+    readonly body: any;
+};

package/dist/src/core/ApiResult.js

@@ -0,0 +1 @@
+export {};

package/dist/src/core/CancelablePromise.d.ts

@@ -0,0 +1,20 @@
+export declare class CancelError extends Error {
+    constructor(message: string);
+    get isCancelled(): boolean;
+}
+export interface OnCancel {
+    readonly isResolved: boolean;
+    readonly isRejected: boolean;
+    readonly isCancelled: boolean;
+    (cancelHandler: () => void): void;
+}
+export declare class CancelablePromise<T> implements Promise<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void, onCancel: OnCancel) => void);
+    get [Symbol.toStringTag](): string;
+    then<TResult1 = T, TResult2 = never>(onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onRejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onRejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onFinally?: (() => void) | null): Promise<T>;
+    cancel(): void;
+    get isCancelled(): boolean;
+}

package/dist/src/core/CancelablePromise.js

@@ -0,0 +1,108 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _CancelablePromise_isResolved, _CancelablePromise_isRejected, _CancelablePromise_isCancelled, _CancelablePromise_cancelHandlers, _CancelablePromise_promise, _CancelablePromise_resolve, _CancelablePromise_reject;
+/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export class CancelError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'CancelError';
+    }
+    get isCancelled() {
+        return true;
+    }
+}
+export class CancelablePromise {
+    constructor(executor) {
+        _CancelablePromise_isResolved.set(this, void 0);
+        _CancelablePromise_isRejected.set(this, void 0);
+        _CancelablePromise_isCancelled.set(this, void 0);
+        _CancelablePromise_cancelHandlers.set(this, void 0);
+        _CancelablePromise_promise.set(this, void 0);
+        _CancelablePromise_resolve.set(this, void 0);
+        _CancelablePromise_reject.set(this, void 0);
+        __classPrivateFieldSet(this, _CancelablePromise_isResolved, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isRejected, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, false, "f");
+        __classPrivateFieldSet(this, _CancelablePromise_cancelHandlers, [], "f");
+        __classPrivateFieldSet(this, _CancelablePromise_promise, new Promise((resolve, reject) => {
+            __classPrivateFieldSet(this, _CancelablePromise_resolve, resolve, "f");
+            __classPrivateFieldSet(this, _CancelablePromise_reject, reject, "f");
+            const onResolve = (value) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isResolved, true, "f");
+                __classPrivateFieldGet(this, _CancelablePromise_resolve, "f")?.call(this, value);
+            };
+            const onReject = (reason) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldSet(this, _CancelablePromise_isRejected, true, "f");
+                __classPrivateFieldGet(this, _CancelablePromise_reject, "f")?.call(this, reason);
+            };
+            const onCancel = (cancelHandler) => {
+                if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+                    return;
+                }
+                __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").push(cancelHandler);
+            };
+            Object.defineProperty(onCancel, 'isResolved', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isResolved, "f"),
+            });
+            Object.defineProperty(onCancel, 'isRejected', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f"),
+            });
+            Object.defineProperty(onCancel, 'isCancelled', {
+                get: () => __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f"),
+            });
+            return executor(onResolve, onReject, onCancel);
+        }), "f");
+    }
+    get [(_CancelablePromise_isResolved = new WeakMap(), _CancelablePromise_isRejected = new WeakMap(), _CancelablePromise_isCancelled = new WeakMap(), _CancelablePromise_cancelHandlers = new WeakMap(), _CancelablePromise_promise = new WeakMap(), _CancelablePromise_resolve = new WeakMap(), _CancelablePromise_reject = new WeakMap(), Symbol.toStringTag)]() {
+        return "Cancellable Promise";
+    }
+    then(onFulfilled, onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").then(onFulfilled, onRejected);
+    }
+    catch(onRejected) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").catch(onRejected);
+    }
+    finally(onFinally) {
+        return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").finally(onFinally);
+    }
+    cancel() {
+        if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
+            return;
+        }
+        __classPrivateFieldSet(this, _CancelablePromise_isCancelled, true, "f");
+        if (__classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length) {
+            try {
+                for (const cancelHandler of __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f")) {
+                    cancelHandler();
+                }
+            }
+            catch (error) {
+                console.warn('Cancellation threw an error', error);
+                return;
+            }
+        }
+        __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length = 0;
+        __classPrivateFieldGet(this, _CancelablePromise_reject, "f")?.call(this, new CancelError('Request aborted'));
+    }
+    get isCancelled() {
+        return __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f");
+    }
+}

package/dist/src/core/OpenAPI.d.ts

@@ -0,0 +1,16 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+type Headers = Record<string, string>;
+export type OpenAPIConfig = {
+    BASE: string;
+    VERSION: string;
+    WITH_CREDENTIALS: boolean;
+    CREDENTIALS: 'include' | 'omit' | 'same-origin';
+    TOKEN?: string | Resolver<string> | undefined;
+    USERNAME?: string | Resolver<string> | undefined;
+    PASSWORD?: string | Resolver<string> | undefined;
+    HEADERS?: Headers | Resolver<Headers> | undefined;
+    ENCODE_PATH?: ((path: string) => string) | undefined;
+};
+export declare const OpenAPI: OpenAPIConfig;
+export {};

package/dist/src/core/OpenAPI.js

@@ -0,0 +1,11 @@
+export const OpenAPI = {
+    BASE: '/api',
+    VERSION: '1.125.0',
+    WITH_CREDENTIALS: false,
+    CREDENTIALS: 'include',
+    TOKEN: undefined,
+    USERNAME: undefined,
+    PASSWORD: undefined,
+    HEADERS: undefined,
+    ENCODE_PATH: undefined,
+};

package/dist/src/core/request.d.ts

@@ -0,0 +1,30 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+import { CancelablePromise } from './CancelablePromise';
+import type { OnCancel } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+export declare const isDefined: <T>(value: T | null | undefined) => value is Exclude<T, null | undefined>;
+export declare const isString: (value: any) => value is string;
+export declare const isStringWithValue: (value: any) => value is string;
+export declare const isBlob: (value: any) => value is Blob;
+export declare const isFormData: (value: any) => value is FormData;
+export declare const base64: (str: string) => string;
+export declare const getQueryString: (params: Record<string, any>) => string;
+export declare const getFormData: (options: ApiRequestOptions) => FormData | undefined;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+export declare const resolve: <T>(options: ApiRequestOptions, resolver?: T | Resolver<T> | undefined) => Promise<T | undefined>;
+export declare const getHeaders: (config: OpenAPIConfig, options: ApiRequestOptions) => Promise<Headers>;
+export declare const getRequestBody: (options: ApiRequestOptions) => any;
+export declare const sendRequest: (config: OpenAPIConfig, options: ApiRequestOptions, url: string, body: any, formData: FormData | undefined, headers: Headers, onCancel: OnCancel) => Promise<Response>;
+export declare const getResponseHeader: (response: Response, responseHeader?: string) => string | undefined;
+export declare const getResponseBody: (response: Response) => Promise<any>;
+export declare const catchErrorCodes: (options: ApiRequestOptions, result: ApiResult) => void;
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export declare const request: <T>(config: OpenAPIConfig, options: ApiRequestOptions) => CancelablePromise<T>;
+export {};