windmill-client 0.3.11 → 0.3.12

package/dist/client.js

@@ -1,24 +1,16 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { ResourceService, VariableService } from "./index";
-import { OpenAPI } from "./index";
-export { AdminService, AuditService, FlowService, GranularAclService, GroupService, JobService, ResourceService, VariableService, ScriptService, ScheduleService, SettingsService, UserService, WorkspaceService, } from "./index";
+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) {
-    var _a, _b, _c;
     if (baseUrl === undefined) {
         baseUrl =
-            (_b = (_a = getEnv("BASE_INTERNAL_URL")) !== null && _a !== void 0 ? _a : getEnv("BASE_URL")) !== null && _b !== void 0 ? _b : "http://localhost:8000";
+            getEnv("BASE_INTERNAL_URL") ??
+                getEnv("BASE_URL") ??
+                "http://localhost:8000";
     }
     if (token === undefined) {
-        token = (_c = getEnv("WM_TOKEN")) !== null && _c !== void 0 ? _c : "no_token";
+        token = getEnv("WM_TOKEN") ?? "no_token";
     }
     OpenAPI.WITH_CREDENTIALS = true;
     OpenAPI.TOKEN = token;
@@ -37,8 +29,7 @@ const getEnv = (key) => {
  * @returns client configuration
  */
 export function getWorkspace() {
-    var _a;
-    return (_a = getEnv("WM_WORKSPACE")) !== null && _a !== void 0 ? _a : "no_workspace";
+    return getEnv("WM_WORKSPACE") ?? "no_workspace";
 }
 /**
  * Get a resource value by path
@@ -46,38 +37,34 @@ export function getWorkspace() {
  * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
  * @returns resource value
  */
-export function getResource(path, undefinedIfEmpty) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const workspace = getWorkspace();
-        path = path !== null && path !== void 0 ? path : getStatePath();
-        try {
-            const resource = yield ResourceService.getResource({ workspace, path });
-            return yield _transformLeaf(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;
         }
-        catch (e) {
-            if (undefinedIfEmpty && e.status === 404) {
-                return undefined;
-            }
-            else {
-                throw Error(`Resource not found at ${path} or not visible to you`);
-            }
+        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 function resolveDefaultResource(obj) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if (typeof obj === "string" && obj.startsWith("$res:")) {
-            return yield getResource(obj.substring(5), true);
-        }
-        else {
-            return obj;
-        }
-    });
+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
@@ -85,24 +72,22 @@ export function resolveDefaultResource(obj) {
  * @param undefinedIfEmpty if the resource does not exist, return undefined instead of throwing an error
  * @returns full resource
  */
-export function getFullResource(path, undefinedIfEmpty) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const workspace = getWorkspace();
-        path = path !== null && path !== void 0 ? path : getStatePath();
-        try {
-            const resource = yield ResourceService.getResource({ workspace, path });
-            const value = yield _transformLeaf(resource.value);
-            return Object.assign(Object.assign({}, resource), { value });
+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;
         }
-        catch (e) {
-            if (undefinedIfEmpty && e.status === 404) {
-                return undefined;
-            }
-            else {
-                throw Error(`Resource not found at ${path} or not visible to you`);
-            }
+        else {
+            throw Error(`Resource not found at ${path} or not visible to you`);
         }
-    });
+    }
 }
 export function getStatePath() {
     const state_path = getEnv("WM_STATE_PATH");
@@ -117,46 +102,40 @@ export function getStatePath() {
  * @param value new value of the resource to set
  * @param initializeToTypeIfNotExist if the resource does not exist, initialize it with this type
  */
-export function setResource(value, path, initializeToTypeIfNotExist) {
-    return __awaiter(this, void 0, void 0, function* () {
-        path = path !== null && path !== void 0 ? path : getStatePath();
-        const workspace = getWorkspace();
-        if (yield ResourceService.existsResource({ workspace, path })) {
-            yield ResourceService.updateResourceValue({
-                workspace,
-                path,
-                requestBody: { value },
-            });
-        }
-        else if (initializeToTypeIfNotExist) {
-            yield 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`);
-        }
-    });
+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 function setInternalState(state) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield setResource(state, undefined, "state");
-    });
+export async function setInternalState(state) {
+    await setResource(state, undefined, "state");
 }
 /**
  * Set the state
  * @param state state to set
  */
-export function setState(state) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield setResource(state, undefined, "state");
-    });
+export async function setState(state) {
+    await setResource(state, undefined, "state");
 }
 // /**
 //  * Set the shared state
@@ -179,35 +158,29 @@ export function setState(state) {
  * Get the internal state
  * @deprecated use getState instead
  */
-export function getInternalState() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield getResource(getStatePath(), true);
-    });
+export async function getInternalState() {
+    return await getResource(getStatePath(), true);
 }
 /**
  * Get the state shared across executions
  */
-export function getState() {
-    return __awaiter(this, void 0, void 0, function* () {
-        return yield getResource(getStatePath(), true);
-    });
+export async function getState() {
+    return await getResource(getStatePath(), true);
 }
 /**
  * Get a variable by path
  * @param path path of the variable
  * @returns variable value
  */
-export function getVariable(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const workspace = getWorkspace();
-        try {
-            const variable = yield VariableService.getVariable({ workspace, path });
-            return variable.value;
-        }
-        catch (e) {
-            throw Error(`Variable not found at ${path} or not visible to you`);
-        }
-    });
+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
@@ -216,62 +189,54 @@ export function getVariable(path) {
  * @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 function setVariable(path, value, isSecretIfNotExist, descriptionIfNotExist) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const workspace = getWorkspace();
-        if (yield VariableService.existsVariable({ workspace, path })) {
-            yield VariableService.updateVariable({
-                workspace,
+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,
-                requestBody: { value },
-            });
-        }
-        else {
-            yield VariableService.createVariable({
-                workspace,
-                requestBody: {
-                    path,
-                    value,
-                    is_secret: isSecretIfNotExist !== null && isSecretIfNotExist !== void 0 ? isSecretIfNotExist : false,
-                    description: descriptionIfNotExist !== null && descriptionIfNotExist !== void 0 ? descriptionIfNotExist : "",
-                },
-            });
-        }
-    });
+                value,
+                is_secret: isSecretIfNotExist ?? false,
+                description: descriptionIfNotExist ?? "",
+            },
+        });
+    }
 }
-function transformLeaves(d) {
-    return __awaiter(this, void 0, void 0, function* () {
-        for (const k in d) {
-            d[k] = yield _transformLeaf(d[k]);
-        }
-        return d;
-    });
+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:";
-function _transformLeaf(v) {
-    return __awaiter(this, void 0, void 0, function* () {
-        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 yield getVariable(varName);
-        }
-        else if (typeof v === "string" && v.startsWith(RES_RESOURCE_PREFIX)) {
-            const resName = v.substring(RES_RESOURCE_PREFIX.length);
-            return yield getResource(resName);
-        }
-        else {
-            return v;
-        }
-    });
+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 function databaseUrlFromResource(path) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const resource = yield getResource(path);
-        return `postgresql://${resource.user}:${resource.password}@${resource.host}:${resource.port}/${resource.dbname}?sslmode=${resource.sslmode}`;
-    });
+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

package/dist/core/CancelablePromise.js

@@ -40,20 +40,18 @@ export class CancelablePromise {
             __classPrivateFieldSet(this, _CancelablePromise_resolve, resolve, "f");
             __classPrivateFieldSet(this, _CancelablePromise_reject, reject, "f");
             const onResolve = (value) => {
-                var _a;
                 if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
                     return;
                 }
                 __classPrivateFieldSet(this, _CancelablePromise_isResolved, true, "f");
-                (_a = __classPrivateFieldGet(this, _CancelablePromise_resolve, "f")) === null || _a === void 0 ? void 0 : _a.call(this, value);
+                __classPrivateFieldGet(this, _CancelablePromise_resolve, "f")?.call(this, value);
             };
             const onReject = (reason) => {
-                var _a;
                 if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
                     return;
                 }
                 __classPrivateFieldSet(this, _CancelablePromise_isRejected, true, "f");
-                (_a = __classPrivateFieldGet(this, _CancelablePromise_reject, "f")) === null || _a === void 0 ? void 0 : _a.call(this, reason);
+                __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")) {
@@ -86,7 +84,6 @@ export class CancelablePromise {
         return __classPrivateFieldGet(this, _CancelablePromise_promise, "f").finally(onFinally);
     }
     cancel() {
-        var _a;
         if (__classPrivateFieldGet(this, _CancelablePromise_isResolved, "f") || __classPrivateFieldGet(this, _CancelablePromise_isRejected, "f") || __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f")) {
             return;
         }
@@ -103,7 +100,7 @@ export class CancelablePromise {
             }
         }
         __classPrivateFieldGet(this, _CancelablePromise_cancelHandlers, "f").length = 0;
-        (_a = __classPrivateFieldGet(this, _CancelablePromise_reject, "f")) === null || _a === void 0 ? void 0 : _a.call(this, new CancelError('Request aborted'));
+        __classPrivateFieldGet(this, _CancelablePromise_reject, "f")?.call(this, new CancelError('Request aborted'));
     }
     get isCancelled() {
         return __classPrivateFieldGet(this, _CancelablePromise_isCancelled, "f");

package/dist/core/request.d.ts

@@ -1,8 +1,4 @@
 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;

package/dist/core/request.js

@@ -1,18 +1,9 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 /* generated using openapi-typescript-codegen -- do no edit */
 /* istanbul ignore file */
 /* tslint:disable */
 /* eslint-disable */
-import { ApiError } from './ApiError';
-import { CancelablePromise } from './CancelablePromise';
+import { ApiError } from './ApiError.js';
+import { CancelablePromise } from './CancelablePromise.js';
 export const isDefined = (value) => {
     return value !== undefined && value !== null;
 };
@@ -79,8 +70,7 @@ const getUrl = (config, options) => {
     const path = options.url
         .replace('{api-version}', config.VERSION)
         .replace(/{(.*?)}/g, (substring, group) => {
-        var _a;
-        if ((_a = options.path) === null || _a === void 0 ? void 0 : _a.hasOwnProperty(group)) {
+        if (options.path?.hasOwnProperty(group)) {
             return encoder(String(options.path[group]));
         }
         return substring;
@@ -116,20 +106,27 @@ export const getFormData = (options) => {
     }
     return undefined;
 };
-export const resolve = (options, resolver) => __awaiter(void 0, void 0, void 0, function* () {
+export const resolve = async (options, resolver) => {
     if (typeof resolver === 'function') {
         return resolver(options);
     }
     return resolver;
-});
-export const getHeaders = (config, options) => __awaiter(void 0, void 0, void 0, function* () {
-    const token = yield resolve(options, config.TOKEN);
-    const username = yield resolve(options, config.USERNAME);
-    const password = yield resolve(options, config.PASSWORD);
-    const additionalHeaders = yield resolve(options, config.HEADERS);
-    const headers = Object.entries(Object.assign(Object.assign({ Accept: 'application/json' }, additionalHeaders), options.headers))
+};
+export const getHeaders = async (config, options) => {
+    const token = await resolve(options, config.TOKEN);
+    const username = await resolve(options, config.USERNAME);
+    const password = await resolve(options, config.PASSWORD);
+    const additionalHeaders = await resolve(options, config.HEADERS);
+    const headers = Object.entries({
+        Accept: 'application/json',
+        ...additionalHeaders,
+        ...options.headers,
+    })
         .filter(([_, value]) => isDefined(value))
-        .reduce((headers, [key, value]) => (Object.assign(Object.assign({}, headers), { [key]: String(value) })), {});
+        .reduce((headers, [key, value]) => ({
+        ...headers,
+        [key]: String(value),
+    }), {});
     if (isStringWithValue(token)) {
         headers['Authorization'] = `Bearer ${token}`;
     }
@@ -152,11 +149,10 @@ export const getHeaders = (config, options) => __awaiter(void 0, void 0, void 0,
         }
     }
     return new Headers(headers);
-});
+};
 export const getRequestBody = (options) => {
-    var _a;
     if (options.body !== undefined) {
-        if ((_a = options.mediaType) === null || _a === void 0 ? void 0 : _a.includes('/json')) {
+        if (options.mediaType?.includes('/json')) {
             return JSON.stringify(options.body);
         }
         else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
@@ -168,11 +164,11 @@ export const getRequestBody = (options) => {
     }
     return undefined;
 };
-export const sendRequest = (config, options, url, body, formData, headers, onCancel) => __awaiter(void 0, void 0, void 0, function* () {
+export const sendRequest = async (config, options, url, body, formData, headers, onCancel) => {
     const controller = new AbortController();
     const request = {
         headers,
-        body: body !== null && body !== void 0 ? body : formData,
+        body: body ?? formData,
         method: options.method,
         signal: controller.signal,
     };
@@ -181,8 +177,8 @@ export const sendRequest = (config, options, url, body, formData, headers, onCan
         request.referrerPolicy = "no-referrer";
     }
     onCancel(() => controller.abort());
-    return yield fetch(url, request);
-});
+    return await fetch(url, request);
+};
 export const getResponseHeader = (response, responseHeader) => {
     if (responseHeader) {
         const content = response.headers.get(responseHeader);
@@ -192,7 +188,7 @@ export const getResponseHeader = (response, responseHeader) => {
     }
     return undefined;
 };
-export const getResponseBody = (response) => __awaiter(void 0, void 0, void 0, function* () {
+export const getResponseBody = async (response) => {
     if (response.status !== 204) {
         try {
             const contentType = response.headers.get('Content-Type');
@@ -200,10 +196,10 @@ export const getResponseBody = (response) => __awaiter(void 0, void 0, void 0, f
                 const jsonTypes = ['application/json', 'application/problem+json'];
                 const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type));
                 if (isJSON) {
-                    return yield response.json();
+                    return await response.json();
                 }
                 else {
-                    return yield response.text();
+                    return await response.text();
                 }
             }
         }
@@ -212,17 +208,25 @@ export const getResponseBody = (response) => __awaiter(void 0, void 0, void 0, f
         }
     }
     return undefined;
-});
+};
 export const catchErrorCodes = (options, result) => {
-    var _a, _b;
-    const errors = Object.assign({ 400: 'Bad Request', 401: 'Unauthorized', 403: 'Forbidden', 404: 'Not Found', 500: 'Internal Server Error', 502: 'Bad Gateway', 503: 'Service Unavailable' }, options.errors);
+    const errors = {
+        400: 'Bad Request',
+        401: 'Unauthorized',
+        403: 'Forbidden',
+        404: 'Not Found',
+        500: 'Internal Server Error',
+        502: 'Bad Gateway',
+        503: 'Service Unavailable',
+        ...options.errors,
+    };
     const error = errors[result.status];
     if (error) {
         throw new ApiError(options, result, error);
     }
     if (!result.ok) {
-        const errorStatus = (_a = result.status) !== null && _a !== void 0 ? _a : 'unknown';
-        const errorStatusText = (_b = result.statusText) !== null && _b !== void 0 ? _b : 'unknown';
+        const errorStatus = result.status ?? 'unknown';
+        const errorStatusText = result.statusText ?? 'unknown';
         const errorBody = (() => {
             try {
                 return JSON.stringify(result.body, null, 2);
@@ -242,22 +246,22 @@ export const catchErrorCodes = (options, result) => {
  * @throws ApiError
  */
 export const request = (config, options) => {
-    return new CancelablePromise((resolve, reject, onCancel) => __awaiter(void 0, void 0, void 0, function* () {
+    return new CancelablePromise(async (resolve, reject, onCancel) => {
         try {
             const url = getUrl(config, options);
             const formData = getFormData(options);
             const body = getRequestBody(options);
-            const headers = yield getHeaders(config, options);
+            const headers = await getHeaders(config, options);
             if (!onCancel.isCancelled) {
-                const response = yield sendRequest(config, options, url, body, formData, headers, onCancel);
-                const responseBody = yield getResponseBody(response);
+                const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+                const responseBody = await getResponseBody(response);
                 const responseHeader = getResponseHeader(response, options.responseHeader);
                 const result = {
                     url,
                     ok: response.ok,
                     status: response.status,
                     statusText: response.statusText,
-                    body: responseHeader !== null && responseHeader !== void 0 ? responseHeader : responseBody,
+                    body: responseHeader ?? responseBody,
                 };
                 catchErrorCodes(options, result);
                 resolve(result.body);
@@ -266,5 +270,5 @@ export const request = (config, options) => {
         catch (error) {
             reject(error);
         }
-    }));
+    });
 };