@tailor-platform/sdk 0.10.4 → 0.11.0

package/dist/{token-DIx5IQOi.mjs → token-43KGC4QJ.mjs}

@@ -1,4 +1,4 @@
-import { getDistDir, tailorUserMap } from "./auth-Di3vQUrT.mjs";
+import { WORKFLOW_JOB_BRAND, getDistDir, tailorUserMap } from "./job-CSwByDTq.mjs";
 import { createRequire } from "node:module";
 import { defineCommand } from "citty";
 import * as path from "node:path";
@@ -7,9 +7,10 @@ import { styleText } from "node:util";
 import * as fs from "node:fs";
 import { z } from "zod";
 import * as inflection from "inflection";
+import ml from "multiline-ts";
 import { readPackageJSON, resolveTSConfig } from "pkg-types";
 import * as rolldown from "rolldown";
-import ml from "multiline-ts";
+import { parseSync } from "oxc-parser";
 import { loadEnvFile } from "node:process";
 import { consola } from "consola";
 import { table } from "table";
@@ -467,6 +468,7 @@ var Application = class {
 	_authService = void 0;
 	_subgraphs = [];
 	_executorService = void 0;
+	_workflowConfig = void 0;
 	_staticWebsiteServices = [];
 	_env = {};
 	constructor(name, config) {
@@ -498,6 +500,9 @@ var Application = class {
 	get executorService() {
 		return this._executorService;
 	}
+	get workflowConfig() {
+		return this._workflowConfig;
+	}
 	get staticWebsiteServices() {
 		return this._staticWebsiteServices;
 	}
@@ -550,6 +555,10 @@ var Application = class {
 		if (!config) return;
 		this._executorService = new ExecutorService(config);
 	}
+	defineWorkflow(config) {
+		if (!config) return;
+		this._workflowConfig = config;
+	}
 	defineStaticWebsites(websites) {
 		const websiteNames = /* @__PURE__ */ new Set();
 		(websites ?? []).forEach((config) => {
@@ -567,232 +576,730 @@ function defineApplication(config) {
 	app.defineIdp(config.idp);
 	app.defineAuth(config.auth);
 	app.defineExecutor(config.executor);
+	app.defineWorkflow(config.workflow);
 	app.defineStaticWebsites(config.staticWebsites);
 	return app;
 }
 
 //#endregion
-//#region src/cli/bundler/bundler.ts
-var Bundler = class {
-	loader;
-	transformer;
-	constructor(config) {
-		this.config = config;
-		this.loader = config.loader;
-		this.transformer = config.transformer;
-	}
-	async bundle() {
-		try {
-			const files = await this.detectFiles();
-			if (files.length === 0) throw new Error(`No files found matching pattern: ${this.config.serviceConfig.files?.join(", ")}`);
-			console.log(`Found ${files.length} files for service "${this.config.namespace}"`);
-			await Promise.all(files.map(async (file) => {
-				await this.processFile(file);
-			}));
-			console.log(`Successfully bundled files for service "${this.config.namespace}"`);
-		} catch (error) {
-			console.error(`Bundle failed for service ${this.config.namespace}:`, error);
-			throw error;
+//#region src/parser/service/workflow/schema.ts
+const WorkflowJobSchema = z.object({
+	name: z.string(),
+	get deps() {
+		return z.array(WorkflowJobSchema).optional();
+	},
+	body: functionSchema
+});
+const WorkflowSchema = z.object({
+	name: z.string(),
+	mainJob: WorkflowJobSchema
+});
+
+//#endregion
+//#region src/cli/application/workflow/service.ts
+/**
+* Load workflow files and collect all jobs in a single pass.
+*/
+async function loadAndCollectJobs(config) {
+	const workflows = {};
+	const workflowSources = [];
+	const collectedJobs = [];
+	let unusedJobs = [];
+	if (!config.files || config.files.length === 0) return {
+		workflows,
+		workflowSources,
+		jobs: collectedJobs,
+		unusedJobs,
+		fileCount: 0
+	};
+	const workflowFiles = loadFilesWithIgnores(config);
+	const fileCount = workflowFiles.length;
+	const allJobsMap = /* @__PURE__ */ new Map();
+	for (const workflowFile of workflowFiles) {
+		const { jobs, workflow } = await loadFileContent(workflowFile);
+		if (workflow) {
+			workflowSources.push({
+				workflow,
+				sourceFile: workflowFile
+			});
+			workflows[workflowFile] = workflow;
+		}
+		for (const job of jobs) {
+			const existing = allJobsMap.get(job.name);
+			if (existing) throw new Error(`Duplicate job name "${job.name}" found:\n  - ${existing.sourceFile} (export: ${existing.exportName})\n  - ${job.sourceFile} (export: ${job.exportName})\nEach job must have a unique name.`);
+			allJobsMap.set(job.name, job);
 		}
 	}
-	async detectFiles() {
-		if (!this.config.serviceConfig.files || this.config.serviceConfig.files.length === 0) return [];
-		return loadFilesWithIgnores(this.config.serviceConfig);
+	const tracedJobs = /* @__PURE__ */ new Map();
+	for (const { workflow } of workflowSources) traceJobDependencies(workflow.mainJob, tracedJobs);
+	const notExportedJobs = [];
+	for (const jobName of tracedJobs.keys()) if (!allJobsMap.has(jobName)) notExportedJobs.push(jobName);
+	if (notExportedJobs.length > 0) throw new Error(`The following workflow jobs are used but not exported:\n` + notExportedJobs.map((name) => `  - "${name}"`).join("\n") + "\n\nAll workflow jobs must be named exports. Example:\n  export const myJob = createWorkflowJob({ name: \"my-job\", ... });\n\nAlso ensure that files containing job exports are included in the workflow.files glob pattern.");
+	unusedJobs = Array.from(allJobsMap.keys()).filter((jobName) => !tracedJobs.has(jobName));
+	for (const [jobName, job] of tracedJobs) {
+		const exportedMetadata = allJobsMap.get(jobName);
+		const depNames = job.deps?.map((dep) => dep.name);
+		collectedJobs.push({
+			...exportedMetadata,
+			deps: depNames
+		});
 	}
-	async processFile(file) {
-		const item = await this.loader.load(file);
-		if (!item) {
-			console.log(`Skipping file ${file} as it could not be loaded`);
-			return;
-		}
-		if (this.config.shouldProcess && !this.config.shouldProcess(item)) {
-			console.log(`Skipping item based on shouldProcess condition: ${file}`);
-			return;
-		}
-		const itemName = item.name;
-		const outputFile = path.join(getDistDir(), this.config.outputDirs.preBundle, `${itemName}.js`);
-		await this.preBundle(file, outputFile);
-		const transformedFiles = await this.transformer.transform(outputFile, getDistDir());
-		if (transformedFiles.length > 0) await this.postBundle(transformedFiles);
-	}
-	async preBundle(input, output) {
-		const outputDir = path.dirname(output);
-		if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
-		let tsconfig;
-		try {
-			tsconfig = await resolveTSConfig();
-		} catch {
-			tsconfig = void 0;
-		}
-		await rolldown.build(rolldown.defineConfig({
-			input,
-			output: {
-				file: output,
-				format: "esm",
-				sourcemap: false,
-				minify: false,
-				inlineDynamicImports: true
-			},
-			tsconfig,
-			treeshake: {
-				moduleSideEffects: false,
-				annotations: true,
-				unknownGlobalSideEffects: false
-			},
-			logLevel: "silent"
-		}));
-		const stats = fs.statSync(output);
-		console.log(`Pre-bundle output size: ${(stats.size / 1024).toFixed(2)} KB`);
+	return {
+		workflows,
+		workflowSources,
+		jobs: collectedJobs,
+		unusedJobs,
+		fileCount
+	};
+}
+/**
+* Print workflow loading logs.
+*/
+function printLoadedWorkflows(result) {
+	if (result.fileCount === 0) return;
+	console.log("");
+	console.log("Found", styleText("cyanBright", result.fileCount.toString()), "workflow files");
+	for (const { workflow, sourceFile } of result.workflowSources) {
+		const relativePath = path.relative(process.cwd(), sourceFile);
+		console.log("Workflow:", styleText("greenBright", `"${workflow.name}"`), "loaded from", styleText("cyan", relativePath));
 	}
-	async postBundle(files) {
-		const outputDir = path.join(getDistDir(), this.config.outputDirs.postBundle);
-		if (!fs.existsSync(outputDir)) fs.mkdirSync(outputDir, { recursive: true });
-		let tsconfig;
-		try {
-			tsconfig = await resolveTSConfig();
-		} catch {
-			tsconfig = void 0;
+	if (result.unusedJobs.length > 0) console.warn(`⚠️  Warning: Unused workflow jobs found: ${result.unusedJobs.join(", ")}`);
+}
+/**
+* Load a single file and extract jobs and workflow
+*/
+async function loadFileContent(filePath) {
+	const jobs = [];
+	let workflow = null;
+	try {
+		const module = await import(`${pathToFileURL(filePath).href}?t=${Date.now()}`);
+		for (const [exportName, exportValue] of Object.entries(module)) {
+			if (exportName === "default") {
+				const workflowResult = WorkflowSchema.safeParse(exportValue);
+				if (workflowResult.success) workflow = workflowResult.data;
+				continue;
+			}
+			if (isWorkflowJob(exportValue)) {
+				const jobResult = WorkflowJobSchema.safeParse(exportValue);
+				if (jobResult.success) jobs.push({
+					name: jobResult.data.name,
+					exportName,
+					sourceFile: filePath
+				});
+			}
 		}
-		await Promise.all(files.map(async (file) => {
-			const outputFile = path.join(outputDir, path.basename(file));
-			await rolldown.build(rolldown.defineConfig({
-				input: path.resolve(file),
-				output: {
-					file: outputFile,
-					format: "esm",
-					sourcemap: true,
-					minify: true,
-					inlineDynamicImports: true
-				},
-				tsconfig,
-				treeshake: {
-					moduleSideEffects: false,
-					annotations: true,
-					unknownGlobalSideEffects: false
-				},
-				logLevel: "silent"
-			}));
-		}));
+	} catch (error) {
+		const relativePath = path.relative(process.cwd(), filePath);
+		console.error(styleText("red", "Failed to load workflow from"), styleText("redBright", relativePath));
+		console.error(error);
+		throw error;
 	}
-};
+	return {
+		jobs,
+		workflow
+	};
+}
+/**
+* Check if a value is a WorkflowJob by looking for the brand symbol
+*/
+function isWorkflowJob(value) {
+	return value != null && typeof value === "object" && WORKFLOW_JOB_BRAND in value && value[WORKFLOW_JOB_BRAND] === true;
+}
+/**
+* Recursively trace all job dependencies
+*/
+function traceJobDependencies(job, visited) {
+	if (visited.has(job.name)) return;
+	visited.set(job.name, job);
+	if (job.deps && Array.isArray(job.deps)) for (const dep of job.deps) traceJobDependencies(dep, visited);
+}
 
 //#endregion
 //#region src/cli/bundler/executor/loader.ts
-var ExecutorLoader = class {
-	async load(executorFilePath) {
-		const executor = (await import(`${pathToFileURL(executorFilePath).href}?t=${Date.now()}`)).default;
-		const parseResult = ExecutorSchema.safeParse(executor);
-		if (!parseResult.success) return null;
-		return parseResult.data;
-	}
-};
+async function loadExecutor(executorFilePath) {
+	const executor = (await import(`${pathToFileURL(executorFilePath).href}?t=${Date.now()}`)).default;
+	const parseResult = ExecutorSchema.safeParse(executor);
+	if (!parseResult.success) return null;
+	return parseResult.data;
+}
 
 //#endregion
-//#region src/cli/bundler/executor/transformer.ts
-var ExecutorTransformer = class {
-	constructor() {}
-	async transform(filePath, tempDir) {
-		const sourceText = fs.readFileSync(filePath).toString();
-		const transformedPath = path.join(path.dirname(filePath), path.basename(filePath, ".js") + ".transformed.js");
-		const executor = (await import(`${pathToFileURL(filePath)}?t=${(/* @__PURE__ */ new Date()).getTime()}`)).default;
-		const exec = executor.operation;
-		if (exec.kind !== "function" && exec.kind !== "jobFunction") return [];
-		if (!exec.body) throw new Error(`Function reference not found in executor ${executor.name}`);
-		fs.writeFileSync(transformedPath, ml`
-      ${sourceText}
+//#region src/cli/bundler/executor/executor-bundler.ts
+/**
+* Bundle executors from the specified configuration
+*
+* This function:
+* 1. Creates entry file that extracts operation.body
+* 2. Bundles in a single step with tree-shaking
+*/
+async function bundleExecutors(config) {
+	const files = loadFilesWithIgnores(config);
+	if (files.length === 0) throw new Error(`No files found matching pattern: ${config.files?.join(", ")}`);
+	console.log("");
+	console.log("Bundling", styleText("cyanBright", files.length.toString()), "files for", styleText("cyan", "\"executor\""));
+	const executors = [];
+	for (const file of files) {
+		const executor = await loadExecutor(file);
+		if (!executor) {
+			console.log(styleText("dim", `  Skipping: ${file} (could not be loaded)`));
+			continue;
+		}
+		if (!["function", "jobFunction"].includes(executor.operation.kind)) {
+			console.log(styleText("dim", `  Skipping: ${executor.name} (not a function executor)`));
+			continue;
+		}
+		executors.push({
+			name: executor.name,
+			sourceFile: file
+		});
+	}
+	if (executors.length === 0) {
+		console.log(styleText("dim", "  No function executors to bundle"));
+		return;
+	}
+	const outputDir = path.resolve(getDistDir(), "executors");
+	fs.mkdirSync(outputDir, { recursive: true });
+	let tsconfig;
+	try {
+		tsconfig = await resolveTSConfig();
+	} catch {
+		tsconfig = void 0;
+	}
+	await Promise.all(executors.map((executor) => bundleSingleExecutor(executor, outputDir, tsconfig)));
+	console.log(styleText("green", "Bundled"), styleText("cyan", "\"executor\""));
+}
+async function bundleSingleExecutor(executor, outputDir, tsconfig) {
+	const entryPath = path.join(outputDir, `${executor.name}.entry.js`);
+	const absoluteSourcePath = path.resolve(executor.sourceFile).replace(/\\/g, "/");
+	const entryContent = ml`
+    import _internalExecutor from "${absoluteSourcePath}";
 
-      // Export the executor function
-      export const __executor_function = ${exec.body.toString()};
-      `);
-		const stepsDir = path.join(tempDir, "executor_steps");
-		fs.mkdirSync(stepsDir, { recursive: true });
-		const executorFilePath = path.join(stepsDir, `${executor.name}.js`);
-		const relativePath = path.relative(stepsDir, transformedPath).replace(/\\/g, "/");
-		const executorContent = ml`
-      import { __executor_function } from "${relativePath}";
+    const __executor_function = _internalExecutor.operation.body;
 
-      globalThis.main = __executor_function;
-    `;
-		fs.writeFileSync(executorFilePath, executorContent);
-		return [executorFilePath];
-	}
-};
+    globalThis.main = __executor_function;
+  `;
+	fs.writeFileSync(entryPath, entryContent);
+	const outputPath = path.join(outputDir, `${executor.name}.js`);
+	await rolldown.build(rolldown.defineConfig({
+		input: entryPath,
+		output: {
+			file: outputPath,
+			format: "esm",
+			sourcemap: true,
+			minify: true,
+			inlineDynamicImports: true
+		},
+		tsconfig,
+		treeshake: {
+			moduleSideEffects: false,
+			annotations: true,
+			unknownGlobalSideEffects: false
+		},
+		logLevel: "silent"
+	}));
+}
 
 //#endregion
 //#region src/cli/bundler/resolver/loader.ts
-var ResolverLoader = class {
-	async load(resolverFilePath) {
-		const resolver = (await import(`${pathToFileURL(resolverFilePath).href}?t=${Date.now()}`)).default;
-		const parseResult = ResolverSchema.safeParse(resolver);
-		if (!parseResult.success) return null;
-		return parseResult.data;
-	}
-};
+async function loadResolver(resolverFilePath) {
+	const resolver = (await import(`${pathToFileURL(resolverFilePath).href}?t=${Date.now()}`)).default;
+	const parseResult = ResolverSchema.safeParse(resolver);
+	if (!parseResult.success) return null;
+	return parseResult.data;
+}
 
 //#endregion
-//#region src/cli/bundler/resolver/transformer.ts
-var CodeTransformer = class {
-	constructor() {}
-	async transform(filePath, tempDir) {
-		const sourceText = fs.readFileSync(filePath).toString();
-		const transformedPath = path.join(path.dirname(filePath), path.basename(filePath, ".js") + ".transformed.js");
-		const resolver = (await import(`${pathToFileURL(filePath)}?t=${(/* @__PURE__ */ new Date()).getTime()}`)).default;
-		const hasInput = resolver.input && Object.keys(resolver.input).length > 0;
-		const bodyVariableName = "$tailor_resolver_body";
-		const bodyFnStr = resolver.body?.toString() || "() => {}";
-		let modifiedSourceText = sourceText;
-		const defaultExportRegex = /export\s+default\s+createResolver\s*\(/;
-		if (defaultExportRegex.test(sourceText)) {
-			modifiedSourceText = sourceText.replace(defaultExportRegex, "const _internalResolver = createResolver(");
-			modifiedSourceText += "\nexport default _internalResolver;";
-		} else {
-			const bundledExportMatch = sourceText.match(/export\s*\{\s*(\w+)\s+as\s+default\s*\}/);
-			if (bundledExportMatch) {
-				const exportedName = bundledExportMatch[1];
-				modifiedSourceText += `\nconst _internalResolver = ${exportedName};`;
-			}
+//#region src/cli/bundler/resolver/resolver-bundler.ts
+/**
+* Bundle resolvers for the specified namespace
+*
+* This function:
+* 1. Uses a transform plugin to add validation wrapper during bundling
+* 2. Creates entry file
+* 3. Bundles in a single step with tree-shaking
+*/
+async function bundleResolvers(namespace, config) {
+	const files = loadFilesWithIgnores(config);
+	if (files.length === 0) throw new Error(`No files found matching pattern: ${config.files?.join(", ")}`);
+	console.log("");
+	console.log("Bundling", styleText("cyanBright", files.length.toString()), "files for", styleText("cyan", `"${namespace}"`));
+	const resolvers = [];
+	for (const file of files) {
+		const resolver = await loadResolver(file);
+		if (!resolver) {
+			console.log(styleText("dim", `  Skipping: ${file} (could not be loaded)`));
+			continue;
 		}
-		const wrappedBodyCode = hasInput ? ml`
-async (context) => {
-  if (_internalResolver.input) {
-    const result = t.object(_internalResolver.input).parse({
-      value: context.input,
-      data: context.input,
-      user: context.user,
-    });
+		resolvers.push({
+			name: resolver.name,
+			sourceFile: file
+		});
+	}
+	const outputDir = path.resolve(getDistDir(), "resolvers");
+	fs.mkdirSync(outputDir, { recursive: true });
+	let tsconfig;
+	try {
+		tsconfig = await resolveTSConfig();
+	} catch {
+		tsconfig = void 0;
+	}
+	await Promise.all(resolvers.map((resolver) => bundleSingleResolver(resolver, outputDir, tsconfig)));
+	console.log(styleText("green", "Bundled"), styleText("cyan", `"${namespace}"`));
+}
+async function bundleSingleResolver(resolver, outputDir, tsconfig) {
+	const entryPath = path.join(outputDir, `${resolver.name}.entry.js`);
+	const absoluteSourcePath = path.resolve(resolver.sourceFile).replace(/\\/g, "/");
+	const entryContent = ml`
+    import _internalResolver from "${absoluteSourcePath}";
+    import { t } from "@tailor-platform/sdk";
 
-    if (result.issues) {
-      const errorMessages = result.issues
-        .map(issue => {
-          const path = issue.path ? issue.path.join('.') : '';
-          return path ? \`  \${path}: \${issue.message}\` : issue.message;
-        })
-        .join('\\n');
-      throw new Error(\`Failed to input validation:\\n\${errorMessages}\`);
-    }
-  }
+    const $tailor_resolver_body = async (context) => {
+      if (_internalResolver.input) {
+        const result = t.object(_internalResolver.input).parse({
+          value: context.input,
+          data: context.input,
+          user: context.user,
+        });
 
-  const originalBody = ${bodyFnStr};
-  return originalBody(context);
+        if (result.issues) {
+          const errorMessages = result.issues
+            .map(issue => {
+              const path = issue.path ? issue.path.join('.') : '';
+              return path ? \`  \${path}: \${issue.message}\` : issue.message;
+            })
+            .join('\\n');
+          throw new Error(\`Failed to input validation:\\n\${errorMessages}\`);
+        }
+      }
+
+      return _internalResolver.body(context);
+    };
+
+    globalThis.main = $tailor_resolver_body;
+  `;
+	fs.writeFileSync(entryPath, entryContent);
+	const outputPath = path.join(outputDir, `${resolver.name}.js`);
+	await rolldown.build(rolldown.defineConfig({
+		input: entryPath,
+		output: {
+			file: outputPath,
+			format: "esm",
+			sourcemap: true,
+			minify: true,
+			inlineDynamicImports: true
+		},
+		tsconfig,
+		treeshake: {
+			moduleSideEffects: false,
+			annotations: true,
+			unknownGlobalSideEffects: false
+		},
+		logLevel: "silent"
+	}));
 }
-` : bodyFnStr;
-		fs.writeFileSync(transformedPath, ml`
-      ${modifiedSourceText}
 
-      export const ${bodyVariableName} = ${wrappedBodyCode};
-      `);
-		const functionDir = path.join(tempDir, "functions");
-		fs.mkdirSync(functionDir, { recursive: true });
-		const bodyFilePath = path.join(functionDir, `${resolver.name}__body.js`);
-		const relativePath = path.relative(functionDir, transformedPath).replace(/\\/g, "/");
-		const bodyContent = ml`
-      import { ${bodyVariableName} } from "${relativePath}";
-      globalThis.main = ${bodyVariableName};
-    `;
-		fs.writeFileSync(bodyFilePath, bodyContent);
-		return [bodyFilePath];
+//#endregion
+//#region src/cli/bundler/workflow/ast-transformer.ts
+/**
+* Check if a module source is from @tailor-platform/sdk (including subpaths)
+*/
+function isTailorSdkSource(source) {
+	return /^@tailor-platform\/sdk(\/|$)/.test(source);
+}
+/**
+* Get the source string from a dynamic import or require call
+*/
+function getImportSource(node) {
+	if (!node) return null;
+	if (node.type === "ImportExpression") {
+		const source = node.source;
+		if (source.type === "Literal" && typeof source.value === "string") return source.value;
+	}
+	if (node.type === "CallExpression") {
+		const callExpr = node;
+		if (callExpr.callee.type === "Identifier" && callExpr.callee.name === "require") {
+			const arg = callExpr.arguments[0];
+			if (arg && "type" in arg && arg.type === "Literal" && "value" in arg && typeof arg.value === "string") return arg.value;
+		}
 	}
-};
+	return null;
+}
+/**
+* Unwrap AwaitExpression to get the inner expression
+*/
+function unwrapAwait(node) {
+	if (node?.type === "AwaitExpression") return node.argument;
+	return node;
+}
+/**
+* Collect all import bindings for createWorkflowJob from @tailor-platform/sdk
+* Returns a Set of local names that refer to createWorkflowJob
+*/
+function collectCreateWorkflowJobBindings(program) {
+	const bindings = /* @__PURE__ */ new Set();
+	function walk(node) {
+		if (!node || typeof node !== "object") return;
+		const nodeType = node.type;
+		if (nodeType === "ImportDeclaration") {
+			const importDecl = node;
+			const source = importDecl.source?.value;
+			if (typeof source === "string" && isTailorSdkSource(source)) {
+				for (const specifier of importDecl.specifiers || []) if (specifier.type === "ImportSpecifier") {
+					const importSpec = specifier;
+					const imported = importSpec.imported.type === "Identifier" ? importSpec.imported.name : importSpec.imported.value;
+					if (imported === "createWorkflowJob") bindings.add(importSpec.local?.name || imported);
+				} else if (specifier.type === "ImportDefaultSpecifier" || specifier.type === "ImportNamespaceSpecifier") {
+					const spec = specifier;
+					bindings.add(`__namespace__:${spec.local?.name}`);
+				}
+			}
+		}
+		if (nodeType === "VariableDeclaration") {
+			const varDecl = node;
+			for (const decl of varDecl.declarations || []) {
+				const init = unwrapAwait(decl.init);
+				const source = getImportSource(init);
+				if (source && isTailorSdkSource(source)) {
+					const id = decl.id;
+					if (id?.type === "Identifier") bindings.add(`__namespace__:${id.name}`);
+					else if (id?.type === "ObjectPattern") {
+						const objPattern = id;
+						for (const prop of objPattern.properties || []) if (prop.type === "Property") {
+							const bindingProp = prop;
+							const keyName = bindingProp.key.type === "Identifier" ? bindingProp.key.name : bindingProp.key.value;
+							if (keyName === "createWorkflowJob") {
+								const localName = bindingProp.value.type === "Identifier" ? bindingProp.value.name : keyName;
+								bindings.add(localName ?? "");
+							}
+						}
+					}
+				}
+			}
+		}
+		for (const key of Object.keys(node)) {
+			const child = node[key];
+			if (Array.isArray(child)) child.forEach((c) => walk(c));
+			else if (child && typeof child === "object") walk(child);
+		}
+	}
+	walk(program);
+	return bindings;
+}
+/**
+* Check if a CallExpression is a createWorkflowJob call
+*/
+function isCreateWorkflowJobCall(node, bindings) {
+	if (node.type !== "CallExpression") return false;
+	const callee = node.callee;
+	if (callee.type === "Identifier") {
+		const identifier = callee;
+		return bindings.has(identifier.name);
+	}
+	if (callee.type === "MemberExpression") {
+		const memberExpr = callee;
+		if (!memberExpr.computed) {
+			const object = memberExpr.object;
+			const property = memberExpr.property;
+			if (object.type === "Identifier" && bindings.has(`__namespace__:${object.name}`) && property.name === "createWorkflowJob") return true;
+		}
+	}
+	return false;
+}
+/**
+* Check if a node is a string literal
+*/
+function isStringLiteral(node) {
+	return node?.type === "Literal" && typeof node.value === "string";
+}
+/**
+* Check if a node is a function expression (arrow or regular)
+*/
+function isFunctionExpression(node) {
+	return node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression";
+}
+/**
+* Find a property in an object expression
+*/
+function findProperty(properties, name) {
+	for (const prop of properties) if (prop.type === "Property") {
+		const objProp = prop;
+		if ((objProp.key.type === "Identifier" ? objProp.key.name : objProp.key.type === "Literal" ? objProp.key.value : null) === name) return {
+			key: objProp.key,
+			value: objProp.value,
+			start: objProp.start,
+			end: objProp.end
+		};
+	}
+	return null;
+}
+/**
+* Find all workflow jobs by detecting createWorkflowJob calls from @tailor-platform/sdk
+*/
+function findAllJobs(program, _sourceText) {
+	const jobs = [];
+	const bindings = collectCreateWorkflowJobBindings(program);
+	function walk(node, parents = []) {
+		if (!node || typeof node !== "object") return;
+		if (isCreateWorkflowJobCall(node, bindings)) {
+			const args = node.arguments;
+			if (args?.length >= 1 && args[0]?.type === "ObjectExpression") {
+				const configObj = args[0];
+				const nameProp = findProperty(configObj.properties, "name");
+				const bodyProp = findProperty(configObj.properties, "body");
+				const depsProp = findProperty(configObj.properties, "deps");
+				if (nameProp && isStringLiteral(nameProp.value) && bodyProp && isFunctionExpression(bodyProp.value)) {
+					let statementRange;
+					for (let i = 0; i < parents.length; i++) {
+						const parent = parents[i];
+						if (parent.type === "ExportNamedDeclaration" || parent.type === "VariableDeclaration") {
+							statementRange = {
+								start: parent.start,
+								end: parent.end
+							};
+							break;
+						}
+					}
+					jobs.push({
+						name: nameProp.value.value,
+						nameRange: {
+							start: nameProp.start,
+							end: nameProp.end
+						},
+						depsRange: depsProp ? {
+							start: depsProp.start,
+							end: depsProp.end
+						} : void 0,
+						bodyValueRange: {
+							start: bodyProp.value.start,
+							end: bodyProp.value.end
+						},
+						statementRange
+					});
+				}
+			}
+		}
+		const newParents = [...parents, node];
+		for (const key of Object.keys(node)) {
+			const child = node[key];
+			if (Array.isArray(child)) child.forEach((c) => walk(c, newParents));
+			else if (child && typeof child === "object") walk(child, newParents);
+		}
+	}
+	walk(program);
+	return jobs;
+}
+/**
+* Apply string replacements to source code
+* Replacements are applied from end to start to maintain positions
+*/
+function applyReplacements(source, replacements) {
+	const sorted = [...replacements].sort((a, b) => b.start - a.start);
+	let result = source;
+	for (const r of sorted) result = result.slice(0, r.start) + r.text + result.slice(r.end);
+	return result;
+}
+/**
+* Find the end position including trailing comma
+*/
+function findTrailingCommaEnd(source, position) {
+	let i = position;
+	while (i < source.length) {
+		const char = source[i];
+		if (char === ",") return i + 1;
+		if (!/\s/.test(char)) break;
+		i++;
+	}
+	return position;
+}
+/**
+* Find the end of a statement including any trailing newline
+*/
+function findStatementEnd(source, position) {
+	let i = position;
+	while (i < source.length && (source[i] === ";" || source[i] === " " || source[i] === "	")) i++;
+	if (i < source.length && source[i] === "\n") i++;
+	return i;
+}
+/**
+* Find variable declarations by export names
+* Returns a map of export name to statement range
+*/
+function findVariableDeclarationsByName(program) {
+	const declarations = /* @__PURE__ */ new Map();
+	function walk(node) {
+		if (!node || typeof node !== "object") return;
+		const nodeType = node.type;
+		if (nodeType === "VariableDeclaration") {
+			const varDecl = node;
+			for (const decl of varDecl.declarations || []) if (decl.id?.type === "Identifier" && decl.id.name) {
+				if (!declarations.has(decl.id.name)) declarations.set(decl.id.name, {
+					start: varDecl.start,
+					end: varDecl.end
+				});
+			}
+		}
+		if (nodeType === "ExportNamedDeclaration") {
+			const exportDecl = node;
+			const declaration = exportDecl.declaration;
+			if (declaration?.type === "VariableDeclaration") {
+				const varDecl = declaration;
+				for (const decl of varDecl.declarations || []) if (decl.id?.type === "Identifier" && decl.id.name) declarations.set(decl.id.name, {
+					start: exportDecl.start,
+					end: exportDecl.end
+				});
+			}
+		}
+		for (const key of Object.keys(node)) {
+			const child = node[key];
+			if (Array.isArray(child)) child.forEach((c) => walk(c));
+			else if (child && typeof child === "object") walk(child);
+		}
+	}
+	walk(program);
+	return declarations;
+}
+/**
+* Transform workflow source code
+* - Target job: remove deps
+* - Other jobs: remove entire variable declaration
+*
+* @param source - The source code to transform
+* @param targetJobName - The name of the target job (from job config)
+* @param targetJobExportName - The export name of the target job (optional, for enhanced detection)
+* @param otherJobExportNames - Export names of other jobs to remove (optional, for enhanced detection)
+*/
+function transformWorkflowSource(source, targetJobName, targetJobExportName, otherJobExportNames) {
+	const { program } = parseSync("input.ts", source);
+	const detectedJobs = findAllJobs(program, source);
+	const allDeclarations = findVariableDeclarationsByName(program);
+	const replacements = [];
+	const removedRanges = /* @__PURE__ */ new Set();
+	const markRemoved = (start, end) => {
+		removedRanges.add(`${start}-${end}`);
+	};
+	const isRemoved = (start, end) => {
+		return removedRanges.has(`${start}-${end}`);
+	};
+	for (const job of detectedJobs) if (job.name === targetJobName) {
+		if (job.depsRange) replacements.push({
+			start: job.depsRange.start,
+			end: findTrailingCommaEnd(source, job.depsRange.end),
+			text: ""
+		});
+	} else if (job.statementRange && !isRemoved(job.statementRange.start, job.statementRange.end)) {
+		replacements.push({
+			start: job.statementRange.start,
+			end: findStatementEnd(source, job.statementRange.end),
+			text: ""
+		});
+		markRemoved(job.statementRange.start, job.statementRange.end);
+	} else if (!job.statementRange) replacements.push({
+		start: job.bodyValueRange.start,
+		end: job.bodyValueRange.end,
+		text: "() => {}"
+	});
+	if (otherJobExportNames) for (const exportName of otherJobExportNames) {
+		if (exportName === targetJobExportName) continue;
+		const declRange = allDeclarations.get(exportName);
+		if (declRange && !isRemoved(declRange.start, declRange.end)) {
+			replacements.push({
+				start: declRange.start,
+				end: findStatementEnd(source, declRange.end),
+				text: ""
+			});
+			markRemoved(declRange.start, declRange.end);
+		}
+	}
+	return applyReplacements(source, replacements);
+}
+
+//#endregion
+//#region src/cli/bundler/workflow/workflow-bundler.ts
+/**
+* Bundle workflow jobs
+*
+* This function:
+* 1. Uses a transform plugin to remove deps during bundling (preserves module resolution)
+* 2. Creates entry file
+* 3. Bundles in a single step with tree-shaking
+*/
+async function bundleWorkflowJobs(allJobs) {
+	if (allJobs.length === 0) {
+		console.log(styleText("dim", "No workflow jobs to bundle"));
+		return;
+	}
+	console.log("");
+	console.log("Bundling", styleText("cyanBright", allJobs.length.toString()), "files for", styleText("cyan", "\"workflow-job\""));
+	const outputDir = path.resolve(getDistDir(), "workflow-jobs");
+	fs.mkdirSync(outputDir, { recursive: true });
+	let tsconfig;
+	try {
+		tsconfig = await resolveTSConfig();
+	} catch {
+		tsconfig = void 0;
+	}
+	await Promise.all(allJobs.map((job) => bundleSingleJob(job, allJobs, outputDir, tsconfig)));
+	console.log(styleText("green", "Bundled"), styleText("cyan", "\"workflow-job\""));
+}
+async function bundleSingleJob(job, allJobs, outputDir, tsconfig) {
+	const depsJobNames = findJobDeps(job.name, allJobs);
+	const jobsObject = generateJobsObject(depsJobNames);
+	const entryPath = path.join(outputDir, `${job.name}.entry.js`);
+	const absoluteSourcePath = path.resolve(job.sourceFile).replace(/\\/g, "/");
+	const entryContent = ml`
+    import { ${job.exportName} } from "${absoluteSourcePath}";
+
+    const jobs = {
+      ${jobsObject}
+    };
+
+    globalThis.main = async (input) => {
+      return await ${job.exportName}.body(input, jobs);
+    };
+  `;
+	fs.writeFileSync(entryPath, entryContent);
+	const outputPath = path.join(outputDir, `${job.name}.js`);
+	const otherJobExportNames = allJobs.filter((j) => j.name !== job.name).map((j) => j.exportName);
+	await rolldown.build(rolldown.defineConfig({
+		input: entryPath,
+		output: {
+			file: outputPath,
+			format: "esm",
+			sourcemap: true,
+			minify: true,
+			inlineDynamicImports: true
+		},
+		tsconfig,
+		plugins: [{
+			name: "workflow-transform",
+			transform: {
+				filter: { id: { include: [/\.ts$/, /\.js$/] } },
+				handler(code) {
+					if (!code.includes("createWorkflowJob")) return null;
+					return { code: transformWorkflowSource(code, job.name, job.exportName, otherJobExportNames) };
+				}
+			}
+		}],
+		treeshake: {
+			moduleSideEffects: false,
+			annotations: true,
+			unknownGlobalSideEffects: false
+		},
+		logLevel: "silent"
+	}));
+}
+/**
+* Find the dependencies of a specific job
+*/
+function findJobDeps(targetJobName, allJobs) {
+	return allJobs.find((j) => j.name === targetJobName)?.deps ?? [];
+}
+function generateJobsObject(jobNames) {
+	if (jobNames.length === 0) return "";
+	return jobNames.map((jobName) => {
+		return `"${jobName.replace(/[-\s]/g, "_")}": (args) => tailor.workflow.triggerJobFunction("${jobName}", args)`;
+	}).join(",\n        ");
+}
 
 //#endregion
 //#region src/parser/generator-config/index.ts
@@ -4314,7 +4821,7 @@ async function planResolvers(client, workspaceId, pipelines, executors, deletedS
 	return changeSet;
 }
 function processResolver(resolver, executorUsedResolvers, env) {
-	const functionPath = path.join(getDistDir(), "functions", `${resolver.name}__body.js`);
+	const functionPath = path.join(getDistDir(), "resolvers", `${resolver.name}.js`);
 	let functionCode = "";
 	try {
 		functionCode = fs.readFileSync(functionPath, "utf-8");
@@ -5025,6 +5532,134 @@ function protoGqlOperand(operand) {
 	} };
 }
 
+//#endregion
+//#region src/cli/apply/services/workflow.ts
+async function applyWorkflow(client, changeSet, phase = "create-update") {
+	if (phase === "create-update") {
+		await Promise.all(changeSet.creates.map(async (create) => {
+			const jobFunctions = {};
+			for (const [jobName, script] of create.scripts.entries()) {
+				const response = await client.createWorkflowJobFunction({
+					workspaceId: create.workspaceId,
+					jobFunctionName: jobName,
+					script
+				});
+				if (response.jobFunction) jobFunctions[jobName] = response.jobFunction.version;
+			}
+			await client.createWorkflow({
+				workspaceId: create.workspaceId,
+				workflowName: create.workflow.name,
+				mainJobFunctionName: create.workflow.mainJob.name,
+				jobFunctions
+			});
+		}));
+		await Promise.all(changeSet.updates.map(async (update) => {
+			const jobFunctions = {};
+			for (const [jobName, script] of update.scripts.entries()) {
+				const response = await client.updateWorkflowJobFunction({
+					workspaceId: update.workspaceId,
+					jobFunctionName: jobName,
+					script
+				});
+				if (response.jobFunction) jobFunctions[jobName] = response.jobFunction.version;
+			}
+			await client.updateWorkflow({
+				workspaceId: update.workspaceId,
+				workflowName: update.workflow.name,
+				mainJobFunctionName: update.workflow.mainJob.name,
+				jobFunctions
+			});
+		}));
+	} else if (phase === "delete") await Promise.all(changeSet.deletes.map((del) => client.deleteWorkflow({
+		workspaceId: del.workspaceId,
+		workflowId: del.workflowId
+	})));
+}
+/**
+* Recursively collect all job names from a workflow's mainJob and its dependencies
+*/
+function collectJobNamesFromWorkflow(workflow) {
+	const jobNames = /* @__PURE__ */ new Set();
+	const collectFromJob = (job) => {
+		if (!job || jobNames.has(job.name)) return;
+		jobNames.add(job.name);
+		if (job.deps && Array.isArray(job.deps)) for (const dep of job.deps) collectFromJob(dep);
+	};
+	collectFromJob(workflow.mainJob);
+	return jobNames;
+}
+async function planWorkflow(client, workspaceId, workflows) {
+	const changeSet = new ChangeSet("Workflows");
+	const existingWorkflows = await fetchAll(async (pageToken) => {
+		const response = await client.listWorkflows({
+			workspaceId,
+			pageToken,
+			pageSize: 100,
+			pageDirection: 0
+		});
+		return [response.workflows.map((w) => ({
+			id: w.id,
+			name: w.name
+		})), response.nextPageToken];
+	});
+	const existingWorkflowMap = /* @__PURE__ */ new Map();
+	existingWorkflows.forEach((workflow) => {
+		existingWorkflowMap.set(workflow.name, {
+			id: workflow.id,
+			name: workflow.name
+		});
+	});
+	const allScripts = await loadWorkflowScripts();
+	for (const workflow of Object.values(workflows)) {
+		const requiredJobNames = collectJobNamesFromWorkflow(workflow);
+		const scripts = /* @__PURE__ */ new Map();
+		for (const jobName of requiredJobNames) {
+			const script = allScripts.get(jobName);
+			if (script) scripts.set(jobName, script);
+			else console.warn(`Warning: Script for job "${jobName}" not found in workflow "${workflow.name}"`);
+		}
+		if (existingWorkflowMap.get(workflow.name)) {
+			changeSet.updates.push({
+				name: workflow.name,
+				workspaceId,
+				workflow,
+				scripts
+			});
+			existingWorkflowMap.delete(workflow.name);
+		} else changeSet.creates.push({
+			name: workflow.name,
+			workspaceId,
+			workflow,
+			scripts
+		});
+	}
+	existingWorkflowMap.forEach((existing) => {
+		changeSet.deletes.push({
+			name: existing.name,
+			workspaceId,
+			workflowId: existing.id
+		});
+	});
+	changeSet.print();
+	return changeSet;
+}
+async function loadWorkflowScripts() {
+	const scripts = /* @__PURE__ */ new Map();
+	const jobsDir = path.join(getDistDir(), "workflow-jobs");
+	if (!fs.existsSync(jobsDir)) {
+		console.warn(`Warning: workflow-jobs directory not found at ${jobsDir}`);
+		return scripts;
+	}
+	const files = fs.readdirSync(jobsDir);
+	for (const file of files) if (file.endsWith(".js") && !file.endsWith(".base.js") && !file.endsWith(".transformed.js") && !file.endsWith(".map")) {
+		const jobName = file.replace(/\.js$/, "");
+		const scriptPath = path.join(jobsDir, file);
+		const script = fs.readFileSync(scriptPath, "utf-8");
+		scripts.set(jobName, script);
+	}
+	return scripts;
+}
+
 //#endregion
 //#region src/cli/apply/index.ts
 async function apply(options) {
@@ -5035,8 +5670,11 @@ async function apply(options) {
 	const buildOnly = options?.buildOnly ?? false;
 	await generateUserTypes(config, configPath);
 	const application = defineApplication(config);
+	let workflowResult;
+	if (application.workflowConfig) workflowResult = await loadAndCollectJobs(application.workflowConfig);
 	for (const app$1 of application.applications) for (const pipeline$1 of app$1.resolverServices) await buildPipeline(pipeline$1.namespace, pipeline$1.config);
 	if (application.executorService) await buildExecutor(application.executorService.config);
+	if (workflowResult && workflowResult.jobs.length > 0) await buildWorkflow(workflowResult.jobs);
 	if (buildOnly) return;
 	const accessToken = await loadAccessToken({
 		useProfile: true,
@@ -5050,6 +5688,7 @@ async function apply(options) {
 	for (const tailordb of application.tailorDBServices) await tailordb.loadTypes();
 	for (const pipeline$1 of application.resolverServices) await pipeline$1.loadResolvers();
 	if (application.executorService) await application.executorService.loadExecutors();
+	if (workflowResult) printLoadedWorkflows(workflowResult);
 	console.log("");
 	const ctx = {
 		client,
@@ -5063,6 +5702,7 @@ async function apply(options) {
 	const pipeline = await planPipeline(ctx);
 	const app = await planApplication(ctx);
 	const executor = await planExecutor(ctx);
+	const workflow = await planWorkflow(client, workspaceId, workflowResult?.workflows ?? {});
 	const allConflicts = [
 		...tailorDB.conflicts,
 		...staticWebsite.conflicts,
@@ -5118,6 +5758,8 @@ async function apply(options) {
 	await applyPipeline(client, pipeline, "create-update");
 	await applyApplication(client, app, "create-update");
 	await applyExecutor(client, executor, "create-update");
+	await applyWorkflow(client, workflow, "create-update");
+	await applyWorkflow(client, workflow, "delete");
 	await applyExecutor(client, executor, "delete");
 	await applyApplication(client, app, "delete");
 	await applyPipeline(client, pipeline, "delete");
@@ -5128,31 +5770,13 @@ async function apply(options) {
 	console.log("Successfully applied changes.");
 }
 async function buildPipeline(namespace, config) {
-	const bundlerConfig = {
-		namespace,
-		serviceConfig: config,
-		loader: new ResolverLoader(),
-		transformer: new CodeTransformer(),
-		outputDirs: {
-			preBundle: "resolvers",
-			postBundle: "functions"
-		}
-	};
-	await new Bundler(bundlerConfig).bundle();
+	await bundleResolvers(namespace, config);
 }
 async function buildExecutor(config) {
-	const bundlerConfig = {
-		namespace: "executor",
-		serviceConfig: config,
-		loader: new ExecutorLoader(),
-		transformer: new ExecutorTransformer(),
-		outputDirs: {
-			preBundle: "executors",
-			postBundle: "executors"
-		},
-		shouldProcess: (executor) => ["function", "jobFunction"].includes(executor.operation.kind)
-	};
-	await new Bundler(bundlerConfig).bundle();
+	await bundleExecutors(config);
+}
+async function buildWorkflow(collectedJobs) {
+	await bundleWorkflowJobs(collectedJobs);
 }
 const applyCommand = defineCommand({
 	meta: {
@@ -6318,4 +6942,5 @@ const tokenCommand = defineCommand({
 });
 
 //#endregion
-export { PATScope, apply, applyCommand, commonArgs, createCommand, deleteCommand, fetchAll, fetchLatestToken, fetchUserInfo, formatArgs, generate, generateCommand, generateUserTypes, initOAuth2Client, initOperatorClient, listCommand, listCommand$1, loadAccessToken, loadConfig, loadConfigPath, loadWorkspaceId, machineUserList, machineUserToken, parseFormat, printWithFormat, readPackageJson, readPlatformConfig, show, showCommand, tokenCommand, withCommonArgs, workspaceCreate, workspaceDelete, workspaceList, writePlatformConfig };
+export { PATScope, apply, applyCommand, commonArgs, createCommand, deleteCommand, fetchAll, fetchLatestToken, fetchUserInfo, formatArgs, generate, generateCommand, generateUserTypes, initOAuth2Client, initOperatorClient, listCommand, listCommand$1, loadAccessToken, loadConfig, loadConfigPath, loadWorkspaceId, machineUserList, machineUserToken, parseFormat, printWithFormat, readPackageJson, readPlatformConfig, show, showCommand, tokenCommand, withCommonArgs, workspaceCreate, workspaceDelete, workspaceList, writePlatformConfig };
+//# sourceMappingURL=token-43KGC4QJ.mjs.map