@tailor-platform/sdk 1.60.0 → 1.60.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # @tailor-platform/sdk
 
+## 1.60.2
+
+### Patch Changes
+
+- [#1399](https://github.com/tailor-platform/sdk/pull/1399) [`4b1c61c`](https://github.com/tailor-platform/sdk/commit/4b1c61c51a2c8367ab50b3cd8144a0bfb9074fc1) Thanks [@dqn](https://github.com/dqn)! - Reject duplicate TailorDB type names across application namespaces, including deployed external TailorDB namespaces checked at deploy time. Projects that currently reuse a type name across namespaces will fail validation on the next `generate` or `deploy`; rename the duplicated types before upgrading.
+
+- [#1406](https://github.com/tailor-platform/sdk/pull/1406) [`a10389f`](https://github.com/tailor-platform/sdk/commit/a10389f7498f9817f7dbf235a64496e83e024a85) Thanks [@dqn](https://github.com/dqn)! - Clarify how non-secret runtime `env` values defined in `defineConfig()` are passed to resolvers, executors, workflow jobs, auth hooks, TailorDB migrations, and `function test-run`.
+
+## 1.60.1
+
+### Patch Changes
+
+- [#1356](https://github.com/tailor-platform/sdk/pull/1356) [`be55e45`](https://github.com/tailor-platform/sdk/commit/be55e45ba2a9eeac0d02633aa793a212c8651acf) Thanks [@renovate](https://github.com/apps/renovate)! - fix(deps): update rolldown
+
+- [#1404](https://github.com/tailor-platform/sdk/pull/1404) [`0aa76e9`](https://github.com/tailor-platform/sdk/commit/0aa76e9c25c41b619433838d0848e8e010e2078a) Thanks [@remiposo](https://github.com/remiposo)! - Fix `db.fields.timestamps()` so `updatedAt` is updated on every record update. Since update hooks receive the stored value merged with the input, the previous `value ?? new Date()` fallback froze `updatedAt` at its first value. `createdAt` still respects a user-specified value on create.
+
 ## 1.60.0
 
 ### Minor Changes

package/dist/application-D4tRNn90.mjs

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

package/dist/{application-FnWOxBk7.mjs → application-pusdxz35.mjs}

@@ -1,6 +1,6 @@
 
 import { n as isSdkBranded } from "./brand-DlnJ375c.mjs";
-import { d as initOAuth2Client } from "./client-W5P4NYYX.mjs";
+import { a as fetchAll, d as initOAuth2Client } from "./client-W5P4NYYX.mjs";
 import { a as parseBoolean, n as logger, r as styles } from "./logger-DpJyJvNz.mjs";
 import { n as enumConstantsPlugin, t as EnumConstantsGeneratorID } from "./enum-constants-C7DaWeQo.mjs";
 import { t as multiline } from "./multiline-Cf9ODpr1.mjs";
@@ -21,6 +21,7 @@ import { parseTOML, parseYAML, stringifyYAML } from "confbox";
 import { findUpSync } from "find-up-simple";
 import { lt } from "semver";
 import { xdgConfig } from "xdg-basedir";
+import { Code, ConnectError } from "@connectrpc/connect";
 import { resolveTSConfig } from "pkg-types";
 import * as crypto from "node:crypto";
 import * as rolldown from "rolldown";
@@ -2698,7 +2699,7 @@ function applyRelationMetadataToFieldConfig(fieldConfig, metadata) {
 * @returns Parsed types
 */
 function parseTypes(rawTypes, namespace, typeSourceInfo) {
-	const types = {};
+	const types = createRecord();
 	const allTypeNames = new Set(Object.keys(rawTypes));
 	for (const [typeName, type] of Object.entries(rawTypes)) types[typeName] = parseTailorDBType(type, allTypeNames, rawTypes);
 	buildBackwardRelationships(types, namespace, typeSourceInfo);
@@ -2715,8 +2716,8 @@ function parseTypes(rawTypes, namespace, typeSourceInfo) {
 function parseTailorDBType(type, allTypeNames, rawTypes) {
 	const metadata = type.metadata;
 	const pluralForm = metadata.settings?.pluralForm || inflection.pluralize(type.name);
-	const fields = {};
-	const forwardRelationships = {};
+	const fields = createRecord();
+	const forwardRelationships = createRecord();
 	for (const [fieldName, fieldDef] of Object.entries(type.fields)) {
 		let fieldConfig = parseFieldConfig(fieldDef);
 		const rawRelation = fieldConfig.rawRelation;
@@ -2762,7 +2763,7 @@ function parseTailorDBType(type, allTypeNames, rawTypes) {
 		description: metadata.description,
 		fields,
 		forwardRelationships,
-		backwardRelationships: {},
+		backwardRelationships: createRecord(),
 		settings: metadata.settings || {},
 		permissions: parsePermissions(metadata.permissions || {}),
 		indexes: metadata.indexes,
@@ -2777,8 +2778,8 @@ function parseTailorDBType(type, allTypeNames, rawTypes) {
 * @param typeSourceInfo - Optional type source information
 */
 function buildBackwardRelationships(types, namespace, typeSourceInfo) {
-	const backwardNameSources = {};
-	for (const typeName of Object.keys(types)) backwardNameSources[typeName] = {};
+	const backwardNameSources = Object.create(null);
+	for (const typeName of Object.keys(types)) backwardNameSources[typeName] = Object.create(null);
 	for (const [typeName, type] of Object.entries(types)) for (const [otherTypeName, otherType] of Object.entries(types)) for (const [fieldName, field] of Object.entries(otherType.fields)) if (field.relation && field.relation.targetType === typeName) {
 		let backwardName = field.relation.backwardName;
 		if (!backwardName) {
@@ -2802,26 +2803,26 @@ function buildBackwardRelationships(types, namespace, typeSourceInfo) {
 	const errors = [];
 	for (const [targetTypeName, backwardNames] of Object.entries(backwardNameSources)) {
 		const targetType = types[targetTypeName];
-		const targetTypeSourceInfo = typeSourceInfo?.[targetTypeName];
+		const targetTypeSourceInfo = getTypeSourceInfo(typeSourceInfo, targetTypeName);
 		const targetLocation = targetTypeSourceInfo ? isPluginGeneratedType(targetTypeSourceInfo) ? ` (plugin: ${targetTypeSourceInfo.pluginId})` : ` (${targetTypeSourceInfo.filePath})` : "";
 		for (const [backwardName, sources] of Object.entries(backwardNames)) {
 			if (sources.length > 1) {
 				const sourceList = sources.map((s) => {
-					const sourceInfo = typeSourceInfo?.[s.sourceType];
+					const sourceInfo = getTypeSourceInfo(typeSourceInfo, s.sourceType);
 					const location = sourceInfo ? isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})` : "";
 					return `${s.sourceType}.${s.fieldName}${location}`;
 				}).join(", ");
 				errors.push(`Backward relation name "${backwardName}" on type "${targetTypeName}" is duplicated from: ${sourceList}. Use the "backward" option in .relation() to specify unique names.`);
 			}
-			if (backwardName in targetType.fields) {
+			if (Object.hasOwn(targetType.fields, backwardName)) {
 				const source = sources[0];
-				const sourceInfo = typeSourceInfo?.[source.sourceType];
+				const sourceInfo = getTypeSourceInfo(typeSourceInfo, source.sourceType);
 				const sourceLocation = sourceInfo ? isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})` : "";
 				errors.push(`Backward relation name "${backwardName}" from ${source.sourceType}.${source.fieldName}${sourceLocation} conflicts with existing field "${backwardName}" on type "${targetTypeName}"${targetLocation}. Use the "backward" option in .relation() to specify a different name.`);
 			}
-			if (targetType.files && backwardName in targetType.files) {
+			if (targetType.files && Object.hasOwn(targetType.files, backwardName)) {
 				const source = sources[0];
-				const sourceInfo = typeSourceInfo?.[source.sourceType];
+				const sourceInfo = getTypeSourceInfo(typeSourceInfo, source.sourceType);
 				const sourceLocation = sourceInfo ? isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})` : "";
 				errors.push(`Backward relation name "${backwardName}" from ${source.sourceType}.${source.fieldName}${sourceLocation} conflicts with files field "${backwardName}" on type "${targetTypeName}"${targetLocation}. Use the "backward" option in .relation() to specify a different name.`);
 			}
@@ -2843,32 +2844,34 @@ function validatePluralFormUniqueness(types, namespace, typeSourceInfo) {
 	for (const [, parsedType] of Object.entries(types)) {
 		const singularQuery = inflection.camelize(parsedType.name, true);
 		if (singularQuery === inflection.camelize(parsedType.pluralForm, true)) {
-			const sourceInfo = typeSourceInfo?.[parsedType.name];
+			const sourceInfo = getTypeSourceInfo(typeSourceInfo, parsedType.name);
 			const location = sourceInfo ? isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})` : "";
 			errors.push(`Type "${parsedType.name}"${location} has identical singular and plural query names "${singularQuery}". Use db.type(["${parsedType.name}", "UniquePluralForm"], {...}) to set a unique pluralForm.`);
 		}
 	}
-	const queryNameToSource = {};
+	const queryNameToSource = /* @__PURE__ */ new Map();
 	for (const parsedType of Object.values(types)) {
 		const singularQuery = inflection.camelize(parsedType.name, true);
 		const pluralQuery = inflection.camelize(parsedType.pluralForm, true);
-		if (!queryNameToSource[singularQuery]) queryNameToSource[singularQuery] = [];
-		queryNameToSource[singularQuery].push({
+		const singularSources = queryNameToSource.get(singularQuery) ?? [];
+		singularSources.push({
 			typeName: parsedType.name,
 			kind: "singular"
 		});
+		queryNameToSource.set(singularQuery, singularSources);
 		if (singularQuery !== pluralQuery) {
-			if (!queryNameToSource[pluralQuery]) queryNameToSource[pluralQuery] = [];
-			queryNameToSource[pluralQuery].push({
+			const pluralSources = queryNameToSource.get(pluralQuery) ?? [];
+			pluralSources.push({
 				typeName: parsedType.name,
 				kind: "plural"
 			});
+			queryNameToSource.set(pluralQuery, pluralSources);
 		}
 	}
-	const duplicates = Object.entries(queryNameToSource).filter(([, sources]) => sources.length > 1);
+	const duplicates = [...queryNameToSource].filter(([, sources]) => sources.length > 1);
 	for (const [queryName, sources] of duplicates) {
 		const sourceList = sources.map((s) => {
-			const sourceInfo = typeSourceInfo?.[s.typeName];
+			const sourceInfo = getTypeSourceInfo(typeSourceInfo, s.typeName);
 			const location = sourceInfo ? isPluginGeneratedType(sourceInfo) ? ` (plugin: ${sourceInfo.pluginId})` : ` (${sourceInfo.filePath})` : "";
 			return `"${s.typeName}"${location} (${s.kind})`;
 		}).join(", ");
@@ -2876,6 +2879,12 @@ function validatePluralFormUniqueness(types, namespace, typeSourceInfo) {
 	}
 	if (errors.length > 0) throw new Error(`GraphQL field name conflicts detected in TailorDB service "${namespace}".\n${errors.map((e) => `  - ${e}`).join("\n")}`);
 }
+function getTypeSourceInfo(typeSourceInfo, typeName) {
+	return typeSourceInfo && Object.hasOwn(typeSourceInfo, typeName) ? typeSourceInfo[typeName] : void 0;
+}
+function createRecord() {
+	return Object.create(null);
+}
 
 //#endregion
 //#region src/parser/service/tailordb/schema.ts
@@ -3453,6 +3462,110 @@ async function precompileTailorDBTypeScripts(type, sourceFilePath, tsconfig) {
 	}
 }
 
+//#endregion
+//#region src/cli/services/tailordb/type-name-validation.ts
+/**
+* Format a TailorDB type source for validation errors.
+* @param sourceInfo - Source information captured when loading the type
+* @returns Human-readable source detail
+*/
+function formatTailorDBTypeSourceInfo(sourceInfo) {
+	if (!sourceInfo) return;
+	if (isPluginGeneratedType(sourceInfo)) {
+		const parts = [`plugin ${sourceInfo.pluginId}`];
+		if (sourceInfo.generatedTypeKind) parts.push(`kind ${sourceInfo.generatedTypeKind}`);
+		if (sourceInfo.originalFilePath) parts.push(`source ${sourceInfo.originalFilePath}`);
+		if (sourceInfo.originalExportName) parts.push(`export ${sourceInfo.originalExportName}`);
+		return parts.join(", ");
+	}
+	return `${sourceInfo.filePath} export ${sourceInfo.exportName}`;
+}
+/**
+* Collect TailorDB type-name sources from loaded local services.
+* @param args - Collection inputs
+* @returns Type-name sources for local services
+*/
+function collectLocalTailorDBTypeNameSources(args) {
+	const sources = [];
+	for (const service of args.tailorDBServices) for (const typeName of Object.keys(service.types)) sources.push({
+		namespace: service.namespace,
+		typeName,
+		kind: "local",
+		detail: formatTailorDBTypeSourceInfo(service.typeSourceInfo[typeName])
+	});
+	return sources;
+}
+/**
+* Fetch TailorDB type-name sources for external namespaces.
+* @param args - Fetch inputs
+* @returns Type-name sources for external services
+*/
+async function fetchExternalTailorDBTypeNameSources(args) {
+	return (await Promise.all(args.externalTailorDBNamespaces.map(async (namespace) => {
+		const sources = [];
+		const tailordbTypes = await fetchAll(async (pageToken, maxPageSize) => {
+			try {
+				const { tailordbTypes, nextPageToken } = await args.client.listTailorDBTypes({
+					workspaceId: args.workspaceId,
+					namespaceName: namespace,
+					pageToken,
+					pageSize: maxPageSize
+				});
+				return [tailordbTypes, nextPageToken ?? ""];
+			} catch (error) {
+				if (error instanceof ConnectError && error.code === Code.NotFound) return [[], ""];
+				throw error;
+			}
+		});
+		for (const type of tailordbTypes) sources.push({
+			namespace,
+			typeName: type.name,
+			kind: "external"
+		});
+		return sources;
+	}))).flat();
+}
+/**
+* Assert that TailorDB type names are unique across all supplied sources.
+* @param args - Validation inputs
+*/
+function assertUniqueTailorDBTypeNames(args) {
+	const sourcesByTypeName = /* @__PURE__ */ new Map();
+	for (const source of args.sources) {
+		const existing = sourcesByTypeName.get(source.typeName);
+		if (existing) existing.push(source);
+		else sourcesByTypeName.set(source.typeName, [source]);
+	}
+	const errors = [];
+	for (const [typeName, sources] of sourcesByTypeName) {
+		if (sources.length <= 1) continue;
+		const sourceList = sources.map(formatTailorDBTypeNameSource).join(", ");
+		errors.push(`Type "${typeName}" is defined more than once: ${sourceList}`);
+	}
+	if (errors.length > 0) throw new Error(`Duplicate TailorDB type names detected.
+${errors.map((error) => `  - ${error}`).join("\n")}\nTailorDB type names must be unique across all TailorDB namespaces in an application.`);
+}
+/**
+* Assert local TailorDB type names are unique.
+* @param args - Validation inputs
+*/
+function assertUniqueLocalTailorDBTypeNames(args) {
+	assertUniqueTailorDBTypeNames({ sources: collectLocalTailorDBTypeNameSources(args) });
+}
+/**
+* Assert TailorDB type names are unique across local and external namespaces.
+* @param args - Validation inputs
+*/
+async function assertUniqueTailorDBTypeNamesWithExternal(args) {
+	const localSources = collectLocalTailorDBTypeNameSources(args);
+	const externalSources = args.externalTailorDBNamespaces.length > 0 ? await fetchExternalTailorDBTypeNameSources(args) : [];
+	assertUniqueTailorDBTypeNames({ sources: [...localSources, ...externalSources] });
+}
+function formatTailorDBTypeNameSource(source) {
+	const namespaceLabel = source.kind === "external" ? `external namespace "${source.namespace}"` : `namespace "${source.namespace}"`;
+	return source.detail ? `${namespaceLabel} (${source.detail})` : namespaceLabel;
+}
+
 //#endregion
 //#region src/cli/services/tailordb/service.ts
 /**
@@ -3462,13 +3575,24 @@ async function precompileTailorDBTypeScripts(type, sourceFilePath, tsconfig) {
 */
 function createTailorDBService(params) {
 	const { namespace, config, pluginManager } = params;
-	const rawTypes = {};
+	const createRawTypesByName = () => Object.create(null);
+	const rawTypes = Object.create(null);
 	let types = {};
-	const typeSourceInfo = {};
+	const typeSourceInfo = Object.create(null);
 	const pluginAttachments = /* @__PURE__ */ new Map();
 	let loadPromise;
+	const registerRawType = (rawTypesKey, typeName, type, sourceInfo) => {
+		const existingSourceInfo = Object.hasOwn(typeSourceInfo, typeName) ? typeSourceInfo[typeName] : void 0;
+		if (existingSourceInfo) {
+			const firstSource = formatTailorDBTypeSourceInfo(existingSourceInfo) ?? "unknown source";
+			const secondSource = formatTailorDBTypeSourceInfo(sourceInfo) ?? "unknown source";
+			throw new Error(`Duplicate TailorDB type name "${typeName}" detected in TailorDB service "${namespace}". First: ${firstSource}. Second: ${secondSource}. TailorDB type names must be unique across all TailorDB files in a service.`);
+		}
+		rawTypes[rawTypesKey][typeName] = type;
+		typeSourceInfo[typeName] = sourceInfo;
+	};
 	const doParseTypes = () => {
-		const allTypes = {};
+		const allTypes = createRawTypesByName();
 		for (const fileTypes of Object.values(rawTypes)) for (const [typeName, type] of Object.entries(fileTypes)) allTypes[typeName] = type;
 		types = parseTypes(allTypes, namespace, typeSourceInfo);
 	};
@@ -3493,8 +3617,7 @@ function createTailorDBService(params) {
 		});
 		if (extendedType) rawTypes[sourceFilePath][rawType.name] = extendedType;
 		for (const gen of generatedTypes) {
-			rawTypes[sourceFilePath][gen.typeName] = gen.type;
-			typeSourceInfo[gen.typeName] = {
+			const sourceInfo = {
 				exportName: gen.typeName,
 				pluginId: gen.pluginId,
 				pluginImportPath: gen.pluginImportPath,
@@ -3504,13 +3627,14 @@ function createTailorDBService(params) {
 				pluginConfig: gen.pluginConfig,
 				namespace
 			};
+			registerRawType(sourceFilePath, gen.typeName, gen.type, sourceInfo);
 		}
 		for (const ev of events) if (ev.kind === "extended") logger.log(`  Extended: ${styles.success(ev.typeName)} with ${styles.highlight(ev.fieldCount.toString())} fields by plugin ${styles.info(ev.pluginId)}`);
 		else logger.log(`  Generated: ${styles.success(ev.typeName)} by plugin ${styles.info(ev.pluginId)}`);
 	};
 	const loadTypeFile = async (typeFile, tsconfig) => {
-		rawTypes[typeFile] = {};
-		const loadedTypes = {};
+		rawTypes[typeFile] = createRawTypesByName();
+		const loadedTypes = createRawTypesByName();
 		try {
 			const module = await import(pathToFileURL(typeFile).href);
 			for (const exportName of Object.keys(module)) {
@@ -3523,12 +3647,11 @@ function createTailorDBService(params) {
 				const relativePath = path.relative(process.cwd(), typeFile);
 				logger.log(`Type: ${styles.successBright(`"${result.data.name}"`)} loaded from ${styles.path(relativePath)}`);
 				await precompileTailorDBTypeScripts(result.data, typeFile, tsconfig);
-				rawTypes[typeFile][result.data.name] = result.data;
 				loadedTypes[result.data.name] = result.data;
-				typeSourceInfo[result.data.name] = {
+				registerRawType(typeFile, result.data.name, result.data, {
 					filePath: typeFile,
 					exportName
-				};
+				});
 				if (exportedValue.plugins && Array.isArray(exportedValue.plugins) && exportedValue.plugins.length > 0) {
 					pluginAttachments.set(exportedValue.name, [...exportedValue.plugins]);
 					logger.log(`  Plugin attachments: ${styles.info(exportedValue.plugins.map((p) => p.pluginId).join(", "))}`);
@@ -3558,7 +3681,7 @@ function createTailorDBService(params) {
 		loadTypes: async () => {
 			if (!loadPromise) loadPromise = (async () => {
 				if (!config.files || config.files.length === 0) return;
-				const typeFiles = loadFilesWithIgnores(config);
+				const typeFiles = [...new Set(loadFilesWithIgnores(config))];
 				let tsconfig;
 				try {
 					tsconfig = await resolveTSConfig();
@@ -3579,31 +3702,38 @@ function createTailorDBService(params) {
 			if (!pluginManager) return;
 			const results = await pluginManager.processNamespacePlugins(namespace);
 			const pluginGeneratedKey = "__plugin_generated__";
-			if (!rawTypes[pluginGeneratedKey]) rawTypes[pluginGeneratedKey] = {};
-			let hasGeneratedTypes = false;
-			for (const { pluginId, config, result } of results) {
+			const successfulResults = results.map(({ pluginId, config, result }) => {
 				if (!result.success) {
 					logger.error(result.error);
 					throw new Error(result.error);
 				}
-				const output = result.output;
-				for (const [kind, generatedType] of Object.entries(output.types ?? {})) {
-					rawTypes[pluginGeneratedKey][generatedType.name] = generatedType;
-					hasGeneratedTypes = true;
-					typeSourceInfo[generatedType.name] = {
-						exportName: generatedType.name,
-						pluginId,
-						pluginImportPath: pluginManager.getPluginImportPath(pluginId) ?? "",
-						originalFilePath: "",
-						originalExportName: "",
-						generatedTypeKind: kind,
-						pluginConfig: config,
-						namespace
-					};
-					logger.log(`  Generated: ${styles.success(generatedType.name)} by namespace plugin ${styles.info(pluginId)}`);
-				}
+				return {
+					pluginId,
+					config,
+					output: result.output
+				};
+			});
+			const previousGeneratedTypes = rawTypes[pluginGeneratedKey];
+			const hadPreviousGeneratedTypes = previousGeneratedTypes !== void 0 && Object.keys(previousGeneratedTypes).length > 0;
+			if (previousGeneratedTypes) for (const typeName of Object.keys(previousGeneratedTypes)) delete typeSourceInfo[typeName];
+			rawTypes[pluginGeneratedKey] = createRawTypesByName();
+			let hasGeneratedTypes = false;
+			for (const { pluginId, config, output } of successfulResults) for (const [kind, generatedType] of Object.entries(output.types ?? {})) {
+				const sourceInfo = {
+					exportName: generatedType.name,
+					pluginId,
+					pluginImportPath: pluginManager.getPluginImportPath(pluginId) ?? "",
+					originalFilePath: "",
+					originalExportName: "",
+					generatedTypeKind: kind,
+					pluginConfig: config,
+					namespace
+				};
+				registerRawType(pluginGeneratedKey, generatedType.name, generatedType, sourceInfo);
+				hasGeneratedTypes = true;
+				logger.log(`  Generated: ${styles.success(generatedType.name)} by namespace plugin ${styles.info(pluginId)}`);
 			}
-			if (hasGeneratedTypes) doParseTypes();
+			if (hasGeneratedTypes || hadPreviousGeneratedTypes) doParseTypes();
 		}
 	};
 }
@@ -5775,6 +5905,7 @@ async function loadApplication(params) {
 		await tailordb.loadTypes();
 		await tailordb.processNamespacePlugins();
 	}
+	assertUniqueLocalTailorDBTypeNames({ tailorDBServices: tailordbResult.tailorDBServices });
 	const pluginExecutorFiles = generatePluginFilesIfNeeded(pluginManager, tailordbResult.tailorDBServices, config.path);
 	const executorService = defineExecutor(config.executor, pluginExecutorFiles.length > 0);
 	const workflowService = defineWorkflow(config.workflow);
@@ -5858,5 +5989,5 @@ async function loadApplication(params) {
 }
 
 //#endregion
-export { readPlatformConfig as A, hashFile as C, loadAccessToken as D, fetchLatestToken as E, saveUserTokens as M, writePlatformConfig as N, loadConfigPath as O, hashContent as S, deleteUserTokens as T, composeFunctionTreeshakeOptions as _, WorkflowJobSchema as a, createBundleCache as b, createExecutorService as c, buildExecutorArgsExpr as d, buildResolverOperationHookExpr as f, platformBundleDefinePlugin as g, loadFilesWithIgnores as h, resolveInlineSourcemap as i, resolveTokens as j, loadWorkspaceId 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, createLogLevelTreeshakeOptions as v, loadConfig as w, getDistDir as x, resolveBundleLogLevel as y };
-//# sourceMappingURL=application-FnWOxBk7.mjs.map
+export { loadConfigPath as A, getDistDir as C, deleteUserTokens as D, loadConfig as E, writePlatformConfig as F, readPlatformConfig as M, resolveTokens as N, fetchLatestToken as O, saveUserTokens as P, createBundleCache as S, hashFile as T, loadFilesWithIgnores as _, WorkflowJobSchema as a, createLogLevelTreeshakeOptions as b, createExecutorService as c, buildExecutorArgsExpr as d, buildResolverOperationHookExpr as f, stringifyFunction as g, TailorDBTypeSchema as h, resolveInlineSourcemap as i, loadWorkspaceId as j, loadAccessToken as k, ExecutorSchema as l, assertUniqueTailorDBTypeNamesWithExternal as m, generatePluginFilesIfNeeded as n, ResolverSchema as o, assertUniqueLocalTailorDBTypeNames as p, loadApplication as r, HTTP_METHODS as s, defineApplication as t, INVOKER_EXPR as u, platformBundleDefinePlugin as v, hashContent as w, resolveBundleLogLevel as x, composeFunctionTreeshakeOptions as y };
+//# sourceMappingURL=application-pusdxz35.mjs.map