@tailor-platform/sdk 1.55.1 → 1.56.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @tailor-platform/sdk
 
+## 1.56.0
+
+### Minor Changes
+
+- [#1341](https://github.com/tailor-platform/sdk/pull/1341) [`64b07b4`](https://github.com/tailor-platform/sdk/commit/64b07b4c6f1db868abf2e1ebb9097e0e2f2f3cc6) Thanks [@dqn](https://github.com/dqn)! - Add a `logLevel` config option to remove lower-level `console.*` calls from bundled deployment functions.
+
+### Patch Changes
+
+- [#1345](https://github.com/tailor-platform/sdk/pull/1345) [`ec863f1`](https://github.com/tailor-platform/sdk/commit/ec863f13e7a3ca43e40ad413c1bbe47cd5567c95) Thanks [@dqn](https://github.com/dqn)! - Fix `seed --truncate` deleting only the first page of Built-In IdP `_User` records. The generated truncation script used incorrect pagination keys, so projects with more than one page of users were left with the remaining pages while the command still reported success. All pages are now deleted.
+
+- [#1344](https://github.com/tailor-platform/sdk/pull/1344) [`d3f22da`](https://github.com/tailor-platform/sdk/commit/d3f22da5a9bcd44ca9659ac35a68a20a2cbc1c2a) Thanks [@dqn](https://github.com/dqn)! - Fix CLI auth config losing keyring-stored logins. Running any command without `TAILOR_USE_KEYRING` no longer downgrades `config.yaml` in a way that drops `storage: keyring` users (and dangles their `current_user` reference), which previously logged keyring users out. Configs containing keyring users now stay in V2 format; file-only configs still downgrade to V1 for backward compatibility.
+
+## 1.55.2
+
+### Patch Changes
+
+- [#1190](https://github.com/tailor-platform/sdk/pull/1190) [`6f891e8`](https://github.com/tailor-platform/sdk/commit/6f891e8a0f948ca2b58bb7e1d4ad19efc31cc38c) Thanks [@toiroakr](https://github.com/toiroakr)! - Validate auth service configuration during `deploy` / `generate`, consistent with how IdP, TailorDB, and static websites are already handled. Configs that set both `userProfile` and `machineUserAttributes` now fail with a clearer message: "Specify either `userProfile` or `machineUserAttributes`, not both."
+
+- [#1332](https://github.com/tailor-platform/sdk/pull/1332) [`aa898b7`](https://github.com/tailor-platform/sdk/commit/aa898b7f369c441077973848a92a09152f6bed4f) Thanks [@dqn](https://github.com/dqn)! - Fix `executor get --json` to include typed event trigger metadata such as event types, namespaces, target names, and conditions.
+
 ## 1.55.1
 
 ### Patch Changes

package/dist/application-C9-t0qQb.mjs

@@ -0,0 +1,4 @@
+
+import { n as generatePluginFilesIfNeeded, r as loadApplication, t as defineApplication } from "./application-YHZIkjdy.mjs";
+
+export { defineApplication };

package/dist/{application-DzUlASfA.mjs → application-YHZIkjdy.mjs}

@@ -6,7 +6,7 @@ import { n as enumConstantsPlugin, t as EnumConstantsGeneratorID } from "./enum-
 import { t as multiline } from "./multiline-Cf9ODpr1.mjs";
 import { n as fileUtilsPlugin, t as FileUtilsGeneratorID } from "./file-utils-BHPxPXmn.mjs";
 import { n as kyselyTypePlugin, t as KyselyGeneratorID } from "./kysely-type-D1e0Vwkd.mjs";
-import { n as seedPlugin, r as isPluginGeneratedType, t as SeedGeneratorID } from "./seed-DfLyRh63.mjs";
+import { n as seedPlugin, r as isPluginGeneratedType, t as SeedGeneratorID } from "./seed-C0fE2sJB.mjs";
 import { t as readPackageJson } from "./package-json-DcQApfPQ.mjs";
 import { n as tightenSecretFilePermissions, r as writeSecretFile } from "./secret-file-CWzF8rry.mjs";
 import { builtinModules, createRequire } from "node:module";
@@ -30,12 +30,27 @@ import * as inflection from "inflection";
 import * as globals from "globals";
 import pLimit from "p-limit";
 
+//#region src/parser/app-config/log-level.ts
+const LOG_LEVELS = [
+	"DEBUG",
+	"INFO",
+	"WARN",
+	"ERROR",
+	"SILENT"
+];
+function isLogLevel(value) {
+	return LOG_LEVELS.includes(value);
+}
+
+//#endregion
 //#region src/parser/app-config/schema.ts
 const envValueSchema = z.union([
 	z.string(),
 	z.number(),
 	z.boolean()
 ]);
+const LogLevelSchema = z.enum(LOG_LEVELS);
+const logLevelSchema = z.string().refine((value) => LogLevelSchema.safeParse(value.trim().toUpperCase()).success, { message: `'logLevel' must be one of: ${LOG_LEVELS.join(", ")}.` });
 /**
 * Structural validation schema for `defineConfig({...})`. Validates only
 * top-level fields with platform-side constraints (notably `id`); fields
@@ -55,6 +70,7 @@ const AppConfigSchema = z.object({
 	allowedIpAddresses: z.array(z.string()).optional(),
 	disableIntrospection: z.boolean().optional(),
 	inlineSourcemap: z.boolean().optional(),
+	logLevel: logLevelSchema.optional(),
 	db: z.unknown().optional(),
 	resolver: z.unknown().optional(),
 	idp: z.unknown().optional(),
@@ -329,17 +345,23 @@ function toV1ForDisk(config) {
 			token_expires_at: entry.token_expires_at
 		};
 	}
+	const currentUser = config.current_user && users[config.current_user] ? config.current_user : null;
 	return {
 		version: 1,
 		users,
 		profiles: config.profiles,
-		current_user: config.current_user
+		current_user: currentUser
 	};
 }
 /**
 * Write Tailor Platform CLI configuration to disk.
-* By default, V2 configs are converted to V1 for backward compatibility.
-* Set TAILOR_USE_KEYRING to write V2 format (required for keyring storage).
+* By default, V2 configs are converted to V1 for backward compatibility, so an
+* older SDK can still read the file. Configs containing a keyring user are kept
+* as V2 regardless, because the keyring storage variant is not representable in
+* V1 and downgrading it would silently drop the user's login. Such configs are
+* already V2 on disk (a keyring entry is only ever persisted with
+* TAILOR_USE_KEYRING set), so keeping V2 does not regress backward compatibility.
+* Set TAILOR_USE_KEYRING to write V2 format unconditionally.
 *
 * The config file may contain access/refresh tokens when the OS keyring is
 * unavailable, so it is written via {@link writeSecretFile} so other users
@@ -347,7 +369,9 @@ function toV1ForDisk(config) {
 * @param config - Platform configuration to write
 */
 function writePlatformConfig(config) {
-	writeSecretFile(platformConfigPath(), stringifyYAML(config.version === 2 && !process.env.TAILOR_USE_KEYRING ? toV1ForDisk(config) : config));
+	const configPath = platformConfigPath();
+	const hasKeyringUser = config.version === 2 && Object.values(config.users).some((u) => u?.storage === "keyring");
+	writeSecretFile(configPath, stringifyYAML(config.version === 2 && !process.env.TAILOR_USE_KEYRING && !hasKeyringUser ? toV1ForDisk(config) : config));
 }
 const tcContextConfigSchema = z.object({
 	username: z.string().optional(),
@@ -733,14 +757,14 @@ function combineHash(fileHash, contextHash) {
 * Compute a context hash for cache invalidation across bundlers.
 *
 * Combines the source file path, serialized trigger context, tsconfig hash,
-* sourcemap mode, and an optional prefix (e.g., serialized env variables)
-* into a single SHA-256 hash.
+* sourcemap mode, bundle log level, and an optional prefix (e.g., serialized
+* env variables) into a single SHA-256 hash.
 * @param params - Context hash computation parameters
 * @returns SHA-256 hex digest of the combined context
 */
 function computeBundlerContextHash(params) {
-	const { sourceFile, serializedTriggerContext, tsconfig, inlineSourcemap, prefix } = params;
-	return hashContent((prefix ?? "") + path.resolve(sourceFile) + serializedTriggerContext + (tsconfig ? hashFile(tsconfig) : "") + String(inlineSourcemap ?? false));
+	const { sourceFile, serializedTriggerContext, tsconfig, inlineSourcemap, bundleLogLevel, prefix } = params;
+	return hashContent((prefix ?? "") + path.resolve(sourceFile) + serializedTriggerContext + (tsconfig ? hashFile(tsconfig) : "") + String(inlineSourcemap ?? false) + (bundleLogLevel ?? ""));
 }
 /**
 * Run a build with optional cache restore/save around it.
@@ -1359,6 +1383,83 @@ async function removeStaleEntryFiles(outputDir) {
 	await Promise.all(files.filter((file) => file.endsWith(".entry.js")).map((file) => fs.rm(path.join(outputDir, file), { force: true })));
 }
 
+//#endregion
+//#region src/cli/shared/bundle-log-level.ts
+const INFO_LEVEL_CONSOLE_METHODS = [
+	"console.log",
+	"console.info",
+	"console.table",
+	"console.dir",
+	"console.dirxml",
+	"console.count",
+	"console.countReset",
+	"console.time",
+	"console.timeLog",
+	"console.timeEnd",
+	"console.group",
+	"console.groupCollapsed",
+	"console.groupEnd",
+	"console.clear"
+];
+const DEBUG_LEVEL_CONSOLE_METHODS = ["console.debug", "console.trace"];
+const WARN_LEVEL_CONSOLE_METHODS = ["console.warn"];
+const ERROR_LEVEL_CONSOLE_METHODS = ["console.error"];
+const MANUAL_PURE_FUNCTIONS_BY_LOG_LEVEL = {
+	DEBUG: [],
+	INFO: DEBUG_LEVEL_CONSOLE_METHODS,
+	WARN: [...DEBUG_LEVEL_CONSOLE_METHODS, ...INFO_LEVEL_CONSOLE_METHODS],
+	ERROR: [
+		...DEBUG_LEVEL_CONSOLE_METHODS,
+		...INFO_LEVEL_CONSOLE_METHODS,
+		...WARN_LEVEL_CONSOLE_METHODS
+	],
+	SILENT: [
+		...DEBUG_LEVEL_CONSOLE_METHODS,
+		...INFO_LEVEL_CONSOLE_METHODS,
+		...WARN_LEVEL_CONSOLE_METHODS,
+		...ERROR_LEVEL_CONSOLE_METHODS
+	]
+};
+function normalizeBundleLogLevel(value) {
+	const normalized = value.trim().toUpperCase();
+	return isLogLevel(normalized) ? normalized : void 0;
+}
+function resolveBundleLogLevel(configValue) {
+	if (configValue === void 0) return "DEBUG";
+	const resolved = normalizeBundleLogLevel(configValue);
+	if (resolved) return resolved;
+	throw new Error(`Invalid logLevel "${configValue}". Expected one of: ${LOG_LEVELS.join(", ")}`);
+}
+function manualPureFunctionsForLogLevel(logLevel) {
+	return MANUAL_PURE_FUNCTIONS_BY_LOG_LEVEL[logLevel];
+}
+function createLogLevelTreeshakeOptions(logLevel) {
+	const manualPureFunctions = manualPureFunctionsForLogLevel(logLevel);
+	return manualPureFunctions.length > 0 ? { manualPureFunctions } : {};
+}
+
+//#endregion
+//#region src/cli/shared/function-treeshake.ts
+const BASE_FUNCTION_TREESHAKE_OPTIONS = {
+	moduleSideEffects: false,
+	annotations: true,
+	unknownGlobalSideEffects: false
+};
+function mergeFunctionTreeshakeOptions(fragments) {
+	const merged = {};
+	const manualPureFunctions = /* @__PURE__ */ new Set();
+	for (const fragment of fragments) {
+		Object.assign(merged, fragment);
+		for (const name of fragment.manualPureFunctions ?? []) manualPureFunctions.add(name);
+	}
+	if (manualPureFunctions.size > 0) merged.manualPureFunctions = [...manualPureFunctions];
+	else delete merged.manualPureFunctions;
+	return merged;
+}
+function composeFunctionTreeshakeOptions(fragments = []) {
+	return mergeFunctionTreeshakeOptions([BASE_FUNCTION_TREESHAKE_OPTIONS, ...fragments]);
+}
+
 //#endregion
 //#region src/cli/services/file-loader.ts
 const DEFAULT_IGNORE_PATTERNS = ["**/*.test.ts", "**/*.spec.ts"];
@@ -2193,7 +2294,7 @@ function createTriggerTransformPlugin(triggerContext) {
 * @returns Map of function name to bundled code
 */
 async function bundleAuthHooks(options) {
-	const { configPath, authName, handlerAccessPath, env = {}, triggerContext, cache, inlineSourcemap } = options;
+	const { configPath, authName, handlerAccessPath, env = {}, triggerContext, cache, inlineSourcemap, bundleLogLevel = "DEBUG" } = options;
 	logger.newline();
 	logger.log(`Bundling auth hook for ${styles.info(`"${authName}"`)}`);
 	const outputDir = path.resolve(getDistDir(), "auth-hooks");
@@ -2219,6 +2320,7 @@ async function bundleAuthHooks(options) {
 			serializedTriggerContext,
 			tsconfig,
 			inlineSourcemap,
+			bundleLogLevel,
 			prefix: sortedEnvPrefix
 		}),
 		async build(cachePlugins) {
@@ -2246,11 +2348,8 @@ async function bundleAuthHooks(options) {
 				},
 				tsconfig,
 				plugins,
-				treeshake: {
-					moduleSideEffects: false,
-					annotations: true,
-					unknownGlobalSideEffects: false
-				},
+				transform: { define: { "process.env.LOG_LEVEL": JSON.stringify(bundleLogLevel) } },
+				treeshake: composeFunctionTreeshakeOptions([createLogLevelTreeshakeOptions(bundleLogLevel)]),
 				logLevel: "silent"
 			})).output[0].code;
 		}
@@ -3651,6 +3750,7 @@ const TenantProviderSchema = z.object({
 	signatureField: z.string().describe("Field used as the tenant signature")
 });
 const UserProfileSchema = z.object({
+	namespace: z.string().optional().describe("TailorDB namespace where the user type is defined"),
 	type: z.object({
 		name: z.string(),
 		fields: z.any(),
@@ -3693,16 +3793,17 @@ const AuthConfigBaseSchema = z.object({
 	connections: z.record(z.string(), AuthConnectionConfigSchema).optional().describe("Auth connection definitions for external OAuth2 providers"),
 	publishSessionEvents: z.boolean().optional().describe("Enable publishing session events")
 });
-const AuthConfigSchema = z.union([AuthConfigBaseSchema.extend({
-	userProfile: z.undefined().optional(),
-	machineUserAttributes: z.undefined().optional()
-}), z.xor([AuthConfigBaseSchema.extend({
-	userProfile: UserProfileSchema,
+const AuthConfigSchema = z.xor([AuthConfigBaseSchema.extend({
+	userProfile: UserProfileSchema.optional().describe("User profile configuration"),
 	machineUserAttributes: z.undefined().optional()
 }), AuthConfigBaseSchema.extend({
 	userProfile: z.undefined().optional(),
-	machineUserAttributes: z.record(z.string(), TailorFieldSchema)
-})])]).brand("AuthConfig");
+	machineUserAttributes: z.record(z.string(), TailorFieldSchema).describe("Machine user attribute fields")
+})], { error: (iss) => {
+	if (iss.code !== "invalid_union") return void 0;
+	if (iss.errors.length < 2) return void 0;
+	if (iss.errors.every((variantErrors) => variantErrors.every((e) => e.path.length === 1 && (e.path[0] === "userProfile" || e.path[0] === "machineUserAttributes")))) return "Specify either `userProfile` or `machineUserAttributes`, not both.";
+} }).brand("AuthConfig");
 
 //#endregion
 //#region src/cli/services/auth/service.ts
@@ -3714,18 +3815,12 @@ const AuthConfigSchema = z.union([AuthConfigBaseSchema.extend({
 * @returns A new AuthService instance
 */
 function createAuthService(config, tailorDBServices, externalTailorDBNamespaces) {
-	const parsedConfig = {
-		...config,
-		idProvider: IdProviderSchema.optional().parse(config.idProvider)
-	};
-	const connections = {};
-	if (config.connections) for (const [name, connConfig] of Object.entries(config.connections)) connections[name] = AuthConnectionConfigSchema.parse(connConfig);
+	const connections = config.connections ? { ...config.connections } : {};
 	let userProfile;
 	return {
 		config,
 		tailorDBServices,
 		externalTailorDBNamespaces,
-		parsedConfig,
 		connections,
 		get userProfile() {
 			return userProfile;
@@ -4000,7 +4095,7 @@ async function loadExecutor(executorFilePath) {
 */
 async function bundleExecutors(options) {
 	const bundledCode = /* @__PURE__ */ new Map();
-	const { config, triggerContext, additionalFiles = [], cache, inlineSourcemap } = options;
+	const { config, triggerContext, additionalFiles = [], cache, inlineSourcemap, bundleLogLevel = "DEBUG" } = options;
 	const files = [...loadFilesWithIgnores(config), ...additionalFiles];
 	if (files.length === 0) {
 		logger.warn(`No executor files found for patterns: ${config.files?.join(", ") ?? "(none)"}`);
@@ -4037,18 +4132,19 @@ async function bundleExecutors(options) {
 	} catch {
 		tsconfig = void 0;
 	}
-	const results = await withBundleConcurrency(executors, (executor) => bundleSingleExecutor(executor, outputDir, tsconfig, triggerContext, cache, inlineSourcemap));
+	const results = await withBundleConcurrency(executors, (executor) => bundleSingleExecutor(executor, outputDir, tsconfig, triggerContext, cache, inlineSourcemap, bundleLogLevel));
 	for (const [name, code] of results) bundledCode.set(name, code);
 	logger.log(`${styles.success("Bundled")} ${styles.info("\"executor\"")}`);
 	return bundledCode;
 }
-async function bundleSingleExecutor(executor, outputDir, tsconfig, triggerContext, cache, inlineSourcemap) {
+async function bundleSingleExecutor(executor, outputDir, tsconfig, triggerContext, cache, inlineSourcemap, bundleLogLevel = "DEBUG") {
 	const serializedTriggerContext = serializeTriggerContext(triggerContext);
 	const contextHash = computeBundlerContextHash({
 		sourceFile: executor.sourceFile,
 		serializedTriggerContext,
 		tsconfig,
-		inlineSourcemap
+		inlineSourcemap,
+		bundleLogLevel
 	});
 	const code = await withCache({
 		cache,
@@ -4083,11 +4179,7 @@ async function bundleSingleExecutor(executor, outputDir, tsconfig, triggerContex
 				},
 				tsconfig,
 				plugins,
-				treeshake: {
-					moduleSideEffects: false,
-					annotations: true,
-					unknownGlobalSideEffects: false
-				},
+				treeshake: composeFunctionTreeshakeOptions([createLogLevelTreeshakeOptions(bundleLogLevel)]),
 				logLevel: "silent"
 			})).output[0].code;
 		}
@@ -4214,9 +4306,10 @@ const ADAPTER_BUNDLE_ERROR_BYTES = 256 * 1024;
 * generated dispatcher that routes by `req.method`; `output` is used as is.
 * @param adapters - Detected adapters to bundle
 * @param cache - Optional bundle cache for skipping unchanged builds
+* @param bundleLogLevel - Controls which console calls are kept in bundled code
 * @returns Bundled scripts keyed by adapter name
 */
-async function bundleHttpAdapters(adapters, cache) {
+async function bundleHttpAdapters(adapters, cache, bundleLogLevel = "DEBUG") {
 	if (adapters.length === 0) return {
 		bundledInputs: /* @__PURE__ */ new Map(),
 		bundledOutputs: /* @__PURE__ */ new Map()
@@ -4236,7 +4329,7 @@ async function bundleHttpAdapters(adapters, cache) {
 			adapter,
 			kind
 		}));
-	}), ({ adapter, kind }) => bundleAdapterScript(adapter, kind, outputDir, tsconfig, cache));
+	}), ({ adapter, kind }) => bundleAdapterScript(adapter, kind, outputDir, tsconfig, cache, bundleLogLevel));
 	const bundledInputs = /* @__PURE__ */ new Map();
 	const bundledOutputs = /* @__PURE__ */ new Map();
 	for (const [name, kind, code] of results) if (kind === "input") bundledInputs.set(name, code);
@@ -4247,12 +4340,13 @@ async function bundleHttpAdapters(adapters, cache) {
 		bundledOutputs
 	};
 }
-async function bundleAdapterScript(adapter, kind, outputDir, tsconfig, cache) {
+async function bundleAdapterScript(adapter, kind, outputDir, tsconfig, cache, bundleLogLevel = "DEBUG") {
 	const contextHash = computeBundlerContextHash({
 		sourceFile: adapter.sourceFile,
 		serializedTriggerContext: kind === "input" ? adapter.methods.join(",") : "",
 		tsconfig,
 		inlineSourcemap: false,
+		bundleLogLevel,
 		prefix: kind
 	});
 	const code = await withCache({
@@ -4304,11 +4398,7 @@ async function bundleAdapterScript(adapter, kind, outputDir, tsconfig, cache) {
 					tsconfig,
 					plugins,
 					transform: { target: "es2017" },
-					treeshake: {
-						moduleSideEffects: false,
-						annotations: true,
-						unknownGlobalSideEffects: false
-					},
+					treeshake: composeFunctionTreeshakeOptions([createLogLevelTreeshakeOptions(bundleLogLevel)]),
 					logLevel: "silent"
 				})).output[0].code;
 			} finally {
@@ -4511,9 +4601,10 @@ async function loadResolver(resolverFilePath) {
 * @param triggerContext - Trigger context for workflow/job transformations
 * @param cache - Optional bundle cache for skipping unchanged builds
 * @param inlineSourcemap - Whether to enable inline sourcemaps
+* @param bundleLogLevel - Controls which console calls are kept in bundled code
 * @returns Map of resolver name to bundled code
 */
-async function bundleResolvers(namespace, config, triggerContext, cache, inlineSourcemap) {
+async function bundleResolvers(namespace, config, triggerContext, cache, inlineSourcemap, bundleLogLevel = "DEBUG") {
 	const bundledCode = /* @__PURE__ */ new Map();
 	const files = loadFilesWithIgnores(config);
 	if (files.length === 0) {
@@ -4543,18 +4634,19 @@ async function bundleResolvers(namespace, config, triggerContext, cache, inlineS
 	} catch {
 		tsconfig = void 0;
 	}
-	const results = await withBundleConcurrency(resolvers, (resolver) => bundleSingleResolver(resolver, outputDir, tsconfig, triggerContext, cache, inlineSourcemap));
+	const results = await withBundleConcurrency(resolvers, (resolver) => bundleSingleResolver(resolver, outputDir, tsconfig, triggerContext, cache, inlineSourcemap, bundleLogLevel));
 	for (const [name, code] of results) bundledCode.set(name, code);
 	logger.log(`${styles.success("Bundled")} ${styles.info(`"${namespace}"`)}`);
 	return bundledCode;
 }
-async function bundleSingleResolver(resolver, outputDir, tsconfig, triggerContext, cache, inlineSourcemap) {
+async function bundleSingleResolver(resolver, outputDir, tsconfig, triggerContext, cache, inlineSourcemap, bundleLogLevel = "DEBUG") {
 	const serializedTriggerContext = serializeTriggerContext(triggerContext);
 	const contextHash = computeBundlerContextHash({
 		sourceFile: resolver.sourceFile,
 		serializedTriggerContext,
 		tsconfig,
-		inlineSourcemap
+		inlineSourcemap,
+		bundleLogLevel
 	});
 	const code = await withCache({
 		cache,
@@ -4605,11 +4697,7 @@ async function bundleSingleResolver(resolver, outputDir, tsconfig, triggerContex
 				},
 				tsconfig,
 				plugins,
-				treeshake: {
-					moduleSideEffects: false,
-					annotations: true,
-					unknownGlobalSideEffects: false
-				},
+				treeshake: composeFunctionTreeshakeOptions([createLogLevelTreeshakeOptions(bundleLogLevel)]),
 				logLevel: "silent"
 			})).output[0].code;
 		}
@@ -4840,9 +4928,10 @@ function safeRealpath(p) {
 * @param triggerContext - Trigger context for transformations
 * @param cache - Optional bundle cache for skipping unchanged builds
 * @param inlineSourcemap - Whether to enable inline sourcemaps
+* @param bundleLogLevel - Controls which console calls are kept in bundled code
 * @returns Workflow job bundling result
 */
-async function bundleWorkflowJobs(allJobs, mainJobNames, env = {}, triggerContext, cache, inlineSourcemap) {
+async function bundleWorkflowJobs(allJobs, mainJobNames, env = {}, triggerContext, cache, inlineSourcemap, bundleLogLevel = "DEBUG") {
 	if (allJobs.length === 0) {
 		logger.warn("No workflow jobs to bundle");
 		return {
@@ -4866,7 +4955,7 @@ async function bundleWorkflowJobs(allJobs, mainJobNames, env = {}, triggerContex
 	} catch {
 		tsconfig = void 0;
 	}
-	const results = await withBundleConcurrency(usedJobs, (job) => bundleSingleJob(job, usedJobs, outputDir, tsconfig, env, triggerContext, cache, inlineSourcemap));
+	const results = await withBundleConcurrency(usedJobs, (job) => bundleSingleJob(job, usedJobs, outputDir, tsconfig, env, triggerContext, cache, inlineSourcemap, bundleLogLevel));
 	const bundledCode = /* @__PURE__ */ new Map();
 	for (const [name, code] of results) bundledCode.set(name, code);
 	logger.log(`${styles.success("Bundled")} ${styles.info("\"workflow-job\"")}`);
@@ -4948,7 +5037,7 @@ async function filterUsedJobs(allJobs, mainJobNames) {
 		mainJobDeps
 	};
 }
-async function bundleSingleJob(job, allJobs, outputDir, tsconfig, env, triggerContext, cache, inlineSourcemap) {
+async function bundleSingleJob(job, allJobs, outputDir, tsconfig, env, triggerContext, cache, inlineSourcemap, bundleLogLevel = "DEBUG") {
 	const serializedTriggerContext = serializeTriggerContext(triggerContext);
 	const sortedEnvPrefix = JSON.stringify(Object.fromEntries(Object.entries(env).sort(([a], [b]) => a.localeCompare(b))));
 	const contextHash = computeBundlerContextHash({
@@ -4956,6 +5045,7 @@ async function bundleSingleJob(job, allJobs, outputDir, tsconfig, env, triggerCo
 		serializedTriggerContext,
 		tsconfig,
 		inlineSourcemap,
+		bundleLogLevel,
 		prefix: sortedEnvPrefix
 	});
 	const code = await withCache({
@@ -5006,11 +5096,7 @@ async function bundleSingleJob(job, allJobs, outputDir, tsconfig, env, triggerCo
 				},
 				tsconfig,
 				plugins,
-				treeshake: {
-					moduleSideEffects: false,
-					annotations: true,
-					unknownGlobalSideEffects: false
-				},
+				treeshake: composeFunctionTreeshakeOptions([createLogLevelTreeshakeOptions(bundleLogLevel)]),
 				logLevel: "silent"
 			})).output[0].code;
 		}
@@ -5473,7 +5559,7 @@ function defineAuth(config, tailorDBServices, externalTailorDBNamespaces) {
 		subgraphs
 	};
 	let authService;
-	if (!("external" in config)) authService = createAuthService(config, tailorDBServices, externalTailorDBNamespaces);
+	if (!("external" in config)) authService = createAuthService(AuthConfigSchema.parse(config), tailorDBServices, externalTailorDBNamespaces);
 	subgraphs.push({
 		Type: "auth",
 		Name: config.name
@@ -5644,6 +5730,7 @@ async function loadApplication(params) {
 	if (httpAdapterService) await httpAdapterService.loadAdapters();
 	const triggerContext = await buildTriggerContext(config.workflow, authResult.authService?.config.name);
 	const inlineSourcemap = resolveInlineSourcemap(config.inlineSourcemap);
+	const bundleLogLevel = resolveBundleLogLevel(config.logLevel);
 	const bundledScripts = {
 		resolvers: /* @__PURE__ */ new Map(),
 		executors: /* @__PURE__ */ new Map(),
@@ -5651,7 +5738,7 @@ async function loadApplication(params) {
 		authHooks: /* @__PURE__ */ new Map()
 	};
 	for (const pipeline of resolverResult.resolverServices) {
-		const resolverBundles = await bundleResolvers(pipeline.namespace, pipeline.config, triggerContext, bundleCache, inlineSourcemap);
+		const resolverBundles = await bundleResolvers(pipeline.namespace, pipeline.config, triggerContext, bundleCache, inlineSourcemap, bundleLogLevel);
 		for (const [name, code] of resolverBundles) bundledScripts.resolvers.set(name, code);
 	}
 	if (executorService) bundledScripts.executors = await bundleExecutors({
@@ -5659,12 +5746,13 @@ async function loadApplication(params) {
 		triggerContext,
 		additionalFiles: [...pluginExecutorFiles],
 		cache: bundleCache,
-		inlineSourcemap
+		inlineSourcemap,
+		bundleLogLevel
 	});
 	let workflowBuildResult;
 	if (workflowService && workflowService.jobs.length > 0) {
 		const mainJobNames = workflowService.workflowSources.map((ws) => ws.workflow.mainJob.name);
-		workflowBuildResult = await bundleWorkflowJobs(workflowService.jobs, mainJobNames, config.env ?? {}, triggerContext, bundleCache, inlineSourcemap);
+		workflowBuildResult = await bundleWorkflowJobs(workflowService.jobs, mainJobNames, config.env ?? {}, triggerContext, bundleCache, inlineSourcemap, bundleLogLevel);
 		bundledScripts.workflowJobs = workflowBuildResult.bundledCode;
 	}
 	let httpAdapterBuildResult;
@@ -5673,7 +5761,7 @@ async function loadApplication(params) {
 		sourceFile: a.sourceFile,
 		methods: a.methods,
 		hasOutput: a.hasOutput
-	})), bundleCache);
+	})), bundleCache, bundleLogLevel);
 	if (authResult.authService?.config.hooks?.beforeLogin) {
 		const authName = authResult.authService.config.name;
 		bundledScripts.authHooks = await bundleAuthHooks({
@@ -5683,7 +5771,8 @@ async function loadApplication(params) {
 			env: config.env ?? {},
 			triggerContext,
 			cache: bundleCache,
-			inlineSourcemap
+			inlineSourcemap,
+			bundleLogLevel
 		});
 	}
 	for (const pipeline of resolverResult.resolverServices) await pipeline.loadResolvers();
@@ -5716,5 +5805,5 @@ async function loadApplication(params) {
 }
 
 //#endregion
-export { loadAccessToken as C, resolveTokens as D, readPlatformConfig as E, saveUserTokens as O, fetchLatestToken as S, loadWorkspaceId as T, createBundleCache as _, WorkflowJobSchema as a, loadConfig as b, createExecutorService as c, buildExecutorArgsExpr as d, buildResolverOperationHookExpr as f, loadFilesWithIgnores as g, stringifyFunction as h, resolveInlineSourcemap as i, writePlatformConfig as k, ExecutorSchema as l, TailorDBTypeSchema as m, generatePluginFilesIfNeeded as n, ResolverSchema as o, OAuth2ClientSchema as p, loadApplication as r, HTTP_METHODS as s, defineApplication as t, INVOKER_EXPR as u, getDistDir as v, loadConfigPath as w, deleteUserTokens as x, hashFile as y };
-//# sourceMappingURL=application-DzUlASfA.mjs.map
+export { saveUserTokens as A, deleteUserTokens as C, loadWorkspaceId as D, loadConfigPath as E, readPlatformConfig as O, loadConfig as S, loadAccessToken as T, createLogLevelTreeshakeOptions as _, WorkflowJobSchema as a, getDistDir as b, createExecutorService as c, buildExecutorArgsExpr as d, buildResolverOperationHookExpr as f, composeFunctionTreeshakeOptions as g, loadFilesWithIgnores as h, resolveInlineSourcemap as i, writePlatformConfig as j, resolveTokens as k, ExecutorSchema as l, stringifyFunction as m, generatePluginFilesIfNeeded as n, ResolverSchema as o, TailorDBTypeSchema as p, loadApplication as r, HTTP_METHODS as s, defineApplication as t, INVOKER_EXPR as u, resolveBundleLogLevel as v, fetchLatestToken as w, hashFile as x, createBundleCache as y };
+//# sourceMappingURL=application-YHZIkjdy.mjs.map