vite-plugin-windmill 1.683.0

package/dist/cli.mjs

@@ -0,0 +1,475 @@
+#!/usr/bin/env node
+import { parseArgs } from "node:util";
+import { access, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+import { ApiError, AppService, setClient } from "windmill-client";
+import { createHash } from "node:crypto";
+import { parse } from "yaml";
+//#region src/project.ts
+const RAW_APP_FOLDER_SUFFIXES = [".raw_app", "__raw_app"];
+const RAW_APP_FILE_NAME = "raw_app.yaml";
+const WMILL_CONFIG_FILE_NAME = "wmill.yaml";
+const DEPLOY_IGNORED_FILE_NAMES = new Set([
+	"AGENTS.md",
+	"DATATABLES.md",
+	"package-lock.json",
+	"raw_app.yaml",
+	"wmill.d.ts"
+]);
+const DEPLOY_IGNORED_DIRECTORIES = new Set([
+	".claude",
+	"backend",
+	"dist",
+	"node_modules",
+	"sql_to_apply"
+]);
+const LANGUAGE_BY_EXTENSION = {
+	"bq.sql": "bigquery",
+	"bun.ts": "bun",
+	cs: "csharp",
+	"deno.ts": "deno",
+	"duckdb.sql": "duckdb",
+	"frontend.js": "frontend",
+	go: "go",
+	gql: "graphql",
+	java: "java",
+	"ms.sql": "mssql",
+	"my.sql": "mysql",
+	"native.ts": "nativets",
+	nu: "nu",
+	"odb.sql": "oracledb",
+	"pg.sql": "postgresql",
+	php: "php",
+	"playbook.yml": "ansible",
+	ps1: "powershell",
+	py: "python3",
+	rb: "ruby",
+	rs: "rust",
+	"sf.sql": "snowflake",
+	sh: "bash",
+	ts: "bun"
+};
+const isNodeError = (value) => value instanceof Error && "code" in value;
+const pathExists = async (filePath) => {
+	try {
+		await access(filePath);
+		return true;
+	} catch {
+		return false;
+	}
+};
+const normalizeToPosix = (value) => value.split(path.sep).join("/");
+const dirnameIfPossible = (value) => {
+	const parent = path.dirname(value);
+	return parent === value ? void 0 : parent;
+};
+const findUp = async (startDir, fileName) => {
+	let currentDir = path.resolve(startDir);
+	while (true) {
+		const candidate = path.join(currentDir, fileName);
+		if (await pathExists(candidate)) return candidate;
+		const parentDir = dirnameIfPossible(currentDir);
+		if (!parentDir) return void 0;
+		currentDir = parentDir;
+	}
+};
+const parseYamlFile = async (filePath) => {
+	return parse(await readFile(filePath, "utf8"));
+};
+const resolveRoot = async (explicitRoot, dir) => {
+	if (explicitRoot) {
+		const root = path.resolve(explicitRoot);
+		return {
+			path: await pathExists(path.join(root, WMILL_CONFIG_FILE_NAME)) ? path.join(root, WMILL_CONFIG_FILE_NAME) : void 0,
+			root
+		};
+	}
+	const configPath = await findUp(dir, WMILL_CONFIG_FILE_NAME);
+	return {
+		path: configPath,
+		root: configPath ? path.dirname(configPath) : dir
+	};
+};
+const resolveDir = async (explicitDir) => {
+	const candidate = path.resolve(explicitDir ?? process.cwd());
+	const rawAppPath = await findUp(candidate, RAW_APP_FILE_NAME);
+	if (!rawAppPath) throw new Error(`Could not find ${RAW_APP_FILE_NAME} from ${candidate}`);
+	return path.dirname(rawAppPath);
+};
+const stripRawAppSuffix = (folderName) => {
+	for (const suffix of RAW_APP_FOLDER_SUFFIXES) if (folderName.endsWith(suffix)) return folderName.slice(0, -suffix.length);
+};
+const inferPath = (dir, root) => {
+	const segments = normalizeToPosix(path.relative(root, dir)).split("/").filter(Boolean);
+	if (segments.length === 0) throw new Error(`Could not infer a Windmill app path from ${dir}`);
+	const lastSegment = segments.at(-1);
+	if (!lastSegment) throw new Error(`Could not infer a Windmill app path from ${dir}`);
+	const strippedSegment = stripRawAppSuffix(lastSegment);
+	if (!strippedSegment) throw new Error(`Expected ${dir} to end in .raw_app or __raw_app so the app path can be inferred`);
+	return [...segments.slice(0, -1), strippedSegment].join("/");
+};
+const inferBase = (pathValue) => `/apps_raw/get/${pathValue}/`;
+const resolveEntry = async (dir, value) => {
+	if (value) {
+		const entry = path.resolve(dir, value);
+		if (!await pathExists(entry)) throw new Error(`Entry file does not exist: ${entry}`);
+		return entry;
+	}
+	const tsEntry = path.join(dir, "index.ts");
+	if (await pathExists(tsEntry)) return tsEntry;
+	const tsxEntry = path.join(dir, "index.tsx");
+	if (await pathExists(tsxEntry)) return tsxEntry;
+	throw new Error(`Could not find index.ts or index.tsx inside ${dir}`);
+};
+const resolveEnv = (options) => ({
+	url: options.url ?? process.env.BASE_INTERNAL_URL ?? process.env.BASE_URL,
+	token: options.token ?? process.env.WM_TOKEN,
+	workspace: options.workspace ?? process.env.WM_WORKSPACE
+});
+const resolveProject = async (options = {}) => {
+	const dir = await resolveDir(options.dir);
+	const { path: config, root } = await resolveRoot(options.root, dir);
+	const wmillConfig = config ? await parseYamlFile(config) : {};
+	const pathValue = options.path ?? inferPath(dir, root);
+	const entry = await resolveEntry(dir, options.entry);
+	const { url, token, workspace } = resolveEnv(options);
+	return {
+		base: options.base ?? inferBase(pathValue),
+		config,
+		dir,
+		entry,
+		nonDotted: options.nonDotted ?? wmillConfig.nonDottedPaths ?? false,
+		path: pathValue,
+		root,
+		syncExcludes: wmillConfig.excludes ?? [],
+		ts: options.ts ?? wmillConfig.defaultTs ?? "bun",
+		workspace,
+		token,
+		url,
+		yaml: path.join(dir, RAW_APP_FILE_NAME)
+	};
+};
+const collectStaticFields = (fields) => Object.fromEntries(Object.entries(fields ?? {}).filter(([, field]) => field.type === "static").map(([name, field]) => [name, field.value]));
+const createRawscriptHash = (content) => createHash("sha256").update(content ?? "").digest("hex");
+const resolveTriggerableEntry = async (runnableId, runnable) => {
+	const staticInputs = collectStaticFields(runnable.fields);
+	const allowUserResources = Object.entries(runnable.fields ?? {}).filter(([, field]) => field.allowUserResources).map(([name]) => name);
+	if (runnable.inlineScript) return [`${runnableId}:rawscript/${createRawscriptHash(runnable.inlineScript.content)}`, {
+		allow_user_resources: allowUserResources,
+		one_of_inputs: {},
+		static_inputs: staticInputs
+	}];
+	if (runnable.path && runnable.runType) return [`${runnableId}:${runnable.runType === "hubscript" ? "script" : runnable.runType}/${runnable.path}`, {
+		allow_user_resources: allowUserResources,
+		one_of_inputs: {},
+		static_inputs: staticInputs
+	}];
+};
+const generateRawAppPolicy = async (runnables, policy, isPublic) => {
+	const resolvedTriggerableEntries = (await Promise.all(Object.entries(runnables).map(async ([runnableId, runnable]) => resolveTriggerableEntry(runnableId, runnable)))).filter((entry) => entry !== void 0);
+	return {
+		...policy,
+		execution_mode: isPublic ? "anonymous" : "publisher",
+		triggerables_v2: Object.fromEntries(resolvedTriggerableEntries)
+	};
+};
+const resolveRunnableLanguage = (extension, ts) => {
+	const language = LANGUAGE_BY_EXTENSION[extension];
+	if (!language) return void 0;
+	return extension === "ts" ? ts : language;
+};
+const findRunnableContentFile = async (backendDir, runnableId, allFileNames) => {
+	for (const fileName of allFileNames) {
+		if (fileName.endsWith(".yaml") || fileName.endsWith(".lock")) continue;
+		if (!fileName.startsWith(`${runnableId}.`)) continue;
+		const extension = fileName.slice(runnableId.length + 1);
+		if (!resolveRunnableLanguage(extension, "bun")) continue;
+		return {
+			content: await readFile(path.join(backendDir, fileName), "utf8"),
+			extension
+		};
+	}
+};
+const getRunnableIdFromCodeFile = (fileName) => {
+	if (fileName.endsWith(".yaml") || fileName.endsWith(".lock")) return void 0;
+	for (const extension of Object.keys(LANGUAGE_BY_EXTENSION)) if (fileName.endsWith(`.${extension}`)) return fileName.slice(0, -(extension.length + 1));
+};
+const inlinePathPrefix = "!inline ";
+const dereferenceInlineValue = async (value, localPath) => {
+	if (typeof value !== "string" || !value.startsWith(inlinePathPrefix)) return value;
+	const relativePath = value.slice(8);
+	return readFile(path.join(localPath, relativePath), "utf8");
+};
+const cloneRunnable = async (value, localPath) => {
+	if (Array.isArray(value)) return Promise.all(value.map(async (item) => cloneRunnable(item, localPath)));
+	if (typeof value !== "object" || value === null) return dereferenceInlineValue(value, localPath);
+	const entries = await Promise.all(Object.entries(value).map(async ([key, entryValue]) => [key, await cloneRunnable(entryValue, localPath)]));
+	return Object.fromEntries(entries);
+};
+const loadRunnablesFromBackend = async (backendDir, ts = "bun") => {
+	const runnables = {};
+	try {
+		const allFileNames = (await readdir(backendDir, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name);
+		const processedIds = /* @__PURE__ */ new Set();
+		for (const fileName of allFileNames) {
+			if (!fileName.endsWith(".yaml")) continue;
+			const runnableId = fileName.slice(0, -5);
+			processedIds.add(runnableId);
+			const runnable = await parseYamlFile(path.join(backendDir, fileName));
+			if (runnable.type === "inline") {
+				const contentFile = await findRunnableContentFile(backendDir, runnableId, allFileNames);
+				if (contentFile) {
+					const lockPath = path.join(backendDir, `${runnableId}.lock`);
+					let lock;
+					try {
+						lock = await readFile(lockPath, "utf8");
+					} catch (error) {
+						if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+					}
+					runnable.inlineScript = {
+						...runnable.inlineScript,
+						content: contentFile.content,
+						language: resolveRunnableLanguage(contentFile.extension, ts),
+						...lock ? { lock } : {}
+					};
+				}
+			} else if (runnable.type === "flow" || runnable.type === "hubscript" || runnable.type === "script") {
+				const { type, schema: _schema, ...rest } = runnable;
+				runnables[runnableId] = {
+					...rest,
+					runType: type,
+					type: "path"
+				};
+				continue;
+			}
+			runnables[runnableId] = runnable;
+		}
+		for (const fileName of allFileNames) {
+			const runnableId = getRunnableIdFromCodeFile(fileName);
+			if (!runnableId || processedIds.has(runnableId)) continue;
+			processedIds.add(runnableId);
+			const contentFile = await findRunnableContentFile(backendDir, runnableId, allFileNames);
+			if (!contentFile) continue;
+			const lockPath = path.join(backendDir, `${runnableId}.lock`);
+			let lock;
+			try {
+				lock = await readFile(lockPath, "utf8");
+			} catch (error) {
+				if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+			}
+			runnables[runnableId] = {
+				inlineScript: {
+					content: contentFile.content,
+					language: resolveRunnableLanguage(contentFile.extension, ts),
+					...lock ? { lock } : {}
+				},
+				type: "inline"
+			};
+		}
+	} catch (error) {
+		if (!isNodeError(error) || error.code !== "ENOENT") throw error;
+	}
+	return runnables;
+};
+const matchesSyncExclude = (relativePath, excludes) => excludes.some((pattern) => path.posix.matchesGlob(relativePath, pattern));
+const collectAppFiles = async (dir, options = {}) => {
+	const files = {};
+	const root = options.root ? path.resolve(options.root) : dir;
+	const excludes = options.excludes ?? [];
+	const walk = async (currentDir, relativeDir = "/") => {
+		const entries = await readdir(currentDir, { withFileTypes: true });
+		for (const entry of entries) {
+			const fullPath = path.join(currentDir, entry.name);
+			const relativePath = `${relativeDir}${entry.name}`;
+			const relativeToRoot = normalizeToPosix(path.relative(root, fullPath));
+			if (entry.isDirectory()) {
+				if (DEPLOY_IGNORED_DIRECTORIES.has(entry.name)) continue;
+				await walk(fullPath, `${relativePath}/`);
+				continue;
+			}
+			if (DEPLOY_IGNORED_FILE_NAMES.has(entry.name)) continue;
+			if (matchesSyncExclude(relativeToRoot, excludes)) continue;
+			files[relativePath] = await readFile(fullPath, "utf8");
+		}
+	};
+	await walk(dir);
+	return files;
+};
+const loadRawAppProject = async (project) => {
+	const config = await parseYamlFile(project.yaml);
+	const backendDir = path.join(project.dir, "backend");
+	const backendRunnables = await loadRunnablesFromBackend(backendDir, project.ts);
+	const runnables = await cloneRunnable(Object.keys(backendRunnables).length > 0 ? backendRunnables : config.runnables ?? {}, backendDir);
+	const files = await collectAppFiles(project.dir, {
+		excludes: project.syncExcludes,
+		root: project.root
+	});
+	return {
+		config,
+		files,
+		policy: await generateRawAppPolicy(runnables, config.policy, Boolean(config.public)),
+		runnables,
+		value: {
+			...config.data !== void 0 ? { data: config.data } : {},
+			files,
+			runnables
+		}
+	};
+};
+//#endregion
+//#region src/deploy.ts
+const defaultDeploymentMessage = () => {
+	const sha = process.env.GITHUB_SHA;
+	return sha ? `vite-plugin-windmill deploy ${sha}` : "vite-plugin-windmill deploy";
+};
+const requireProjectConnection = (project) => {
+	if (!project.workspace) throw new Error("Missing Windmill workspace. Set `workspace` or `WM_WORKSPACE`.");
+	if (!project.token) throw new Error("Missing Windmill token. Set `token` or `WM_TOKEN`.");
+	if (!project.url) throw new Error("Missing Windmill URL. Set `url`, `BASE_INTERNAL_URL`, or `BASE_URL`.");
+	return {
+		url: project.url,
+		token: project.token,
+		workspace: project.workspace
+	};
+};
+const readBundleFile = async (filePath, fallback = "") => {
+	try {
+		return await readFile(filePath, "utf8");
+	} catch (error) {
+		if (error instanceof Error && "code" in error && error.code === "ENOENT") return fallback;
+		throw error;
+	}
+};
+const readBundleContents = async (dir, js = path.join(dir, "dist/windmill/bundle.js"), css = path.join(dir, "dist/windmill/bundle.css")) => ({
+	css: await readBundleFile(css, ""),
+	js: await readBundleFile(js)
+});
+const findExistingRawApp = async (workspace, pathValue) => {
+	try {
+		return await AppService.getAppByPath({
+			workspace,
+			path: pathValue
+		});
+	} catch (error) {
+		if (error instanceof ApiError && error.status === 404) return void 0;
+		throw error;
+	}
+};
+/**
+* Deploys a raw app to Windmill using `windmill-client` instead of shelling out to the CLI.
+*/
+const deploy = async (options) => {
+	const dir = options.dir ?? process.cwd();
+	const project = await resolveProject({
+		...options,
+		dir
+	});
+	const rawAppProject = await loadRawAppProject(project);
+	const connection = requireProjectConnection(project);
+	const bundles = options.bundles ?? await readBundleContents(dir, options.js, options.css);
+	if (!bundles.js) throw new Error("Cannot deploy a Windmill raw app without a JavaScript bundle");
+	if (options.dry) return {
+		action: "dry-run",
+		base: project.base,
+		path: project.path,
+		workspace: connection.workspace
+	};
+	setClient(connection.token, connection.url);
+	const existingApp = await findExistingRawApp(connection.workspace, project.path);
+	if (existingApp && !existingApp.raw_app) throw new Error(`${project.path} exists remotely but is not a raw app`);
+	const message = options.message ?? defaultDeploymentMessage();
+	const appPayload = {
+		...rawAppProject.config.custom_path ? { custom_path: rawAppProject.config.custom_path } : {},
+		deployment_message: message,
+		path: project.path,
+		policy: rawAppProject.policy,
+		summary: rawAppProject.config.summary,
+		value: rawAppProject.value
+	};
+	if (existingApp) {
+		await AppService.updateAppRaw({
+			workspace: connection.workspace,
+			path: project.path,
+			formData: {
+				app: appPayload,
+				css: bundles.css,
+				js: bundles.js
+			}
+		});
+		return {
+			action: "update",
+			base: project.base,
+			path: project.path,
+			workspace: connection.workspace
+		};
+	}
+	await AppService.createAppRaw({
+		workspace: connection.workspace,
+		formData: {
+			app: appPayload,
+			css: bundles.css,
+			js: bundles.js
+		}
+	});
+	return {
+		action: "create",
+		base: project.base,
+		path: project.path,
+		workspace: connection.workspace
+	};
+};
+//#endregion
+//#region src/cli.ts
+const main = async () => {
+	const { values } = parseArgs({ options: {
+		base: { type: "string" },
+		css: { type: "string" },
+		dir: { type: "string" },
+		dry: { type: "boolean" },
+		entry: { type: "string" },
+		js: { type: "string" },
+		message: { type: "string" },
+		path: { type: "string" },
+		root: { type: "string" },
+		token: { type: "string" },
+		url: { type: "string" },
+		workspace: { type: "string" },
+		help: {
+			type: "boolean",
+			short: "h"
+		}
+	} });
+	if (values.help) return console.log(`
+Usage: vite-plugin-windmill [options]
+
+Deploy a built Windmill raw app bundle.
+
+Options:
+  -h, --help          Show this help message
+  --base <path>       Override the raw-app base path
+  --css <path>        Path to the CSS file to include in the deployment
+  --dir <path>        Raw-app directory to resolve and deploy from
+  --dry               Perform a dry run without making any changes
+  --entry <path>      Override the raw-app entry file
+  --js <path>         Path to the JavaScript file to include in the deployment
+  --message <text>    Deployment message or description
+  --path <path>       Override the inferred Windmill raw-app path
+  --root <path>       Override the workspace root used to infer the app path
+  --token <token>     Windmill API token for authentication
+  --url <url>         Windmill instance URL
+  --workspace <name>  Windmill workspace name
+
+Connection resolution order:
+  workspace: --workspace, WM_WORKSPACE
+  token:     --token, WM_TOKEN
+  url:       --url, BASE_INTERNAL_URL, BASE_URL
+     `.trim());
+	const result = await deploy(values);
+	console.log(JSON.stringify(result, null, 2));
+};
+main().catch((error) => {
+	console.error(error instanceof Error ? error.message : String(error));
+	process.exitCode = 1;
+});
+//#endregion
+export { main };

package/dist/index.d.mts

@@ -0,0 +1,128 @@
+import { Policy } from "windmill-client";
+import { Plugin, ProxyOptions } from "vite";
+
+//#region src/types.d.ts
+interface WindmillApiProxyOptions extends ProxyOptions {
+  context?: string;
+  enabled?: boolean;
+  target?: string;
+  token?: string;
+}
+interface PluginDeployOptions {
+  deploy?: boolean;
+  dry?: boolean;
+  message?: string;
+}
+interface PluginOptions {
+  base?: string;
+  deploy?: boolean | PluginDeployOptions;
+  dir?: string;
+  entry?: string;
+  message?: string;
+  nonDotted?: boolean;
+  path?: string;
+  proxy?: boolean | WindmillApiProxyOptions;
+  root?: string;
+  token?: string;
+  ts?: string;
+  url?: string;
+  workspace?: string;
+}
+interface Project {
+  base: string;
+  config?: string;
+  dir: string;
+  entry: string;
+  nonDotted: boolean;
+  path: string;
+  root: string;
+  syncExcludes: string[];
+  ts: string;
+  workspace?: string;
+  token?: string;
+  url?: string;
+  yaml: string;
+}
+interface RawAppFileConfig {
+  summary: string;
+  custom_path?: string;
+  public?: boolean;
+  data?: unknown;
+  policy?: Policy;
+  runnables?: Record<string, RawAppRunnable>;
+}
+interface RawAppField {
+  allowUserResources?: boolean;
+  ctx?: string;
+  type?: string;
+  value?: unknown;
+  [key: string]: unknown;
+}
+interface RawInlineScript {
+  cache_ttl?: number;
+  content?: string;
+  id?: number;
+  language?: string;
+  lock?: string;
+  schema?: unknown;
+}
+interface RawAppRunnable {
+  fields?: Record<string, RawAppField>;
+  inlineScript?: RawInlineScript;
+  path?: string;
+  runType?: "flow" | "hubscript" | "script";
+  schema?: unknown;
+  type?: string;
+  [key: string]: unknown;
+}
+interface RawAppProject {
+  config: RawAppFileConfig;
+  files: Record<string, string>;
+  policy: Policy;
+  runnables: Record<string, RawAppRunnable>;
+  value: {
+    data?: unknown;
+    files: Record<string, string>;
+    runnables: Record<string, RawAppRunnable>;
+  };
+}
+interface BundleContents {
+  css: string;
+  js: string;
+}
+interface DeployOptions {
+  base?: string;
+  bundles?: BundleContents;
+  css?: string;
+  dir?: string;
+  dry?: boolean;
+  entry?: string;
+  js?: string;
+  message?: string;
+  path?: string;
+  root?: string;
+  token?: string;
+  url?: string;
+  workspace?: string;
+}
+interface DeployRawAppResult {
+  action: "create" | "dry-run" | "update";
+  base: string;
+  path: string;
+  workspace: string;
+}
+//#endregion
+//#region src/deploy.d.ts
+/**
+ * Deploys a raw app to Windmill using `windmill-client` instead of shelling out to the CLI.
+ */
+declare const deploy: (options: DeployOptions) => Promise<DeployRawAppResult>;
+//#endregion
+//#region src/plugin.d.ts
+/**
+ * Creates a Vite plugin that aligns a SPA with Windmill raw-app build and deploy behavior.
+ */
+declare const windmill: (options?: PluginOptions) => Plugin;
+//#endregion
+export { type BundleContents, type DeployOptions, type DeployRawAppResult, type PluginDeployOptions, type PluginOptions, type Project, type RawAppField, type RawAppFileConfig, type RawAppProject, type RawAppRunnable, type WindmillApiProxyOptions, windmill as default, windmill, deploy };
+//# sourceMappingURL=index.d.mts.map