@tailor-platform/sdk 1.54.3 → 1.55.0

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @tailor-platform/sdk
 
+## 1.55.0
+
+### Minor Changes
+
+- [#1173](https://github.com/tailor-platform/sdk/pull/1173) [`4d8010d`](https://github.com/tailor-platform/sdk/commit/4d8010ddf93edd1e9e7344b7e868b7e6efc3fddf) Thanks [@Mistat](https://github.com/Mistat)! - Add `createHttpAdapter()` for declaring HTTP adapters that translate HTTP requests into GraphQL queries and reshape the responses. Adapter files are discovered via the new `httpAdapter.files` glob in `defineConfig()`.
+
+### Patch Changes
+
+- [#1320](https://github.com/tailor-platform/sdk/pull/1320) [`977c200`](https://github.com/tailor-platform/sdk/commit/977c2007eb6ac28507d6eac1c391448ab91caa2a) Thanks [@remiposo](https://github.com/remiposo)! - `createKyselyMock`: assert what a write wrote as a `{ column: value }` map instead of positional SQL parameters. On a recorded query:
+
+  - `insertValues()` / `insertRows()` — the values a single- / multi-row insert wrote
+  - `updateValues()` — the values an update's SET clause wrote
+  - `node` — the raw Kysely operation node, for anything the helpers don't cover
+
+  Also adds `withTx(fn)` to run `fn` inside a real `Transaction`.
+
+- [#1314](https://github.com/tailor-platform/sdk/pull/1314) [`e423765`](https://github.com/tailor-platform/sdk/commit/e4237652c4ac65074e2bcd1da56adc1841bc71cd) Thanks [@toiroakr](https://github.com/toiroakr)! - Fix generated migrate.ts templates for enum value removal: removed enum values were compared by object identity (so unchanged values were also treated as removed) and rendered as `[object Object]` in the generated migration script.
+
 ## 1.54.3
 
 ### Patch Changes

package/dist/{actor-Cjae_LGD.d.mts → actor-J2gJ0eK5.d.mts}

@@ -1,4 +1,4 @@
-import { Bt as InferredAttributeMap, zt as InferredAttributeList } from "./tailor-db-field-D0qg8s4U.mjs";
+import { A as InferredAttributeList, j as InferredAttributeMap } from "./tailordb-BlBGmQK-.mjs";
 
 //#region src/types/actor.d.ts
 /** User type enum values from the Tailor Platform server. */
@@ -21,4 +21,4 @@ type TailorActor = {
 };
 //#endregion
 export { TailorActor as t };
-//# sourceMappingURL=actor-Cjae_LGD.d.mts.map
+//# sourceMappingURL=actor-J2gJ0eK5.d.mts.map

package/dist/application-DM8q9GDI.mjs

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

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

@@ -1,6 +1,6 @@
 
 import { n as isSdkBranded } from "./brand-DlnJ375c.mjs";
-import { u as initOAuth2Client } from "./client-CGO7gniI.mjs";
+import { u as initOAuth2Client } from "./client-DLPEPJ_s.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";
@@ -9,7 +9,7 @@ import { n as kyselyTypePlugin, t as KyselyGeneratorID } from "./kysely-type-D1e
 import { n as seedPlugin, r as isPluginGeneratedType, t as SeedGeneratorID } from "./seed-DfLyRh63.mjs";
 import { t as readPackageJson } from "./package-json-DcQApfPQ.mjs";
 import { n as tightenSecretFilePermissions, r as writeSecretFile } from "./secret-file-CWzF8rry.mjs";
-import { createRequire } from "node:module";
+import { builtinModules, createRequire } from "node:module";
 import { z } from "zod";
 import * as fs$1 from "node:fs";
 import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
@@ -61,6 +61,7 @@ const AppConfigSchema = z.object({
 	auth: z.unknown().optional(),
 	executor: z.unknown().optional(),
 	workflow: z.unknown().optional(),
+	httpAdapter: z.unknown().optional(),
 	staticWebsites: z.unknown().optional(),
 	secrets: z.unknown().optional()
 });
@@ -4159,6 +4160,315 @@ function createExecutorService(params) {
 	};
 }
 
+//#endregion
+//#region src/cli/services/http-adapter/node-builtins.ts
+const NODE_BUILTINS = new Set(builtinModules.filter((m) => !m.startsWith("_")));
+function isNodeBuiltinImport(source) {
+	if (source.startsWith("node:")) return true;
+	const root = source.includes("/") ? source.slice(0, source.indexOf("/")) : source;
+	return NODE_BUILTINS.has(root);
+}
+
+//#endregion
+//#region src/parser/service/http-adapter/methods.ts
+/**
+* Maps the lowercase `input` handler keys to the HTTP methods they serve.
+* The key set is tied to `inputHandlersSchema` in `./schema` via the
+* zinfer-generated config type, so the two cannot drift apart.
+*/
+const HTTP_METHODS = {
+	get: "GET",
+	post: "POST",
+	put: "PUT",
+	patch: "PATCH",
+	delete: "DELETE"
+};
+const HTTP_METHOD_KEYS = Object.keys(HTTP_METHODS);
+
+//#endregion
+//#region src/parser/service/http-adapter/schema.ts
+const NAME_PATTERN = /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/;
+const inputHandlersSchema = z.strictObject({
+	get: functionSchema.optional().describe("Handler for GET requests"),
+	post: functionSchema.optional().describe("Handler for POST requests"),
+	put: functionSchema.optional().describe("Handler for PUT requests"),
+	patch: functionSchema.optional().describe("Handler for PATCH requests"),
+	delete: functionSchema.optional().describe("Handler for DELETE requests")
+}).refine((val) => Object.values(val).some((v) => v !== void 0), "input must declare at least one HTTP method handler").describe("Per-method functions that transform HTTP requests to GraphQL requests");
+const HttpAdapterConfigSchema = z.strictObject({
+	name: z.string().regex(NAME_PATTERN, "name must be 3-63 chars, lowercase alphanumeric with hyphens, not starting or ending with a hyphen").describe("Unique adapter name within the domain"),
+	pathPattern: z.string().min(1).describe("Path pattern with segment wildcards (trailing or single-segment)"),
+	enabled: z.boolean().default(true).describe("Whether the adapter is active"),
+	priority: z.number().int().min(0).default(0).describe("Matching priority; the lowest value wins when multiple adapters match"),
+	input: inputHandlersSchema,
+	output: functionSchema.optional().describe("Function that transforms GraphQL response to HTTP response")
+}).brand("HttpAdapterConfig");
+
+//#endregion
+//#region src/cli/services/http-adapter/bundler.ts
+const ADAPTER_BUNDLE_WARN_BYTES = 64 * 1024;
+const ADAPTER_BUNDLE_ERROR_BYTES = 256 * 1024;
+/**
+* Bundle each adapter's `input` (and `output`, if present) into a standalone
+* IIFE defining a global `transform(input)` entry point. `input` gets a
+* 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
+* @returns Bundled scripts keyed by adapter name
+*/
+async function bundleHttpAdapters(adapters, cache) {
+	if (adapters.length === 0) return {
+		bundledInputs: /* @__PURE__ */ new Map(),
+		bundledOutputs: /* @__PURE__ */ new Map()
+	};
+	logger.newline();
+	logger.log(`Bundling ${styles.highlight(adapters.length.toString())} files for ${styles.info("\"http-adapter\"")}`);
+	const outputDir = path.resolve(getDistDir(), "http-adapters");
+	fs$1.mkdirSync(outputDir, { recursive: true });
+	let tsconfig;
+	try {
+		tsconfig = await resolveTSConfig();
+	} catch {
+		tsconfig = void 0;
+	}
+	const results = await withBundleConcurrency(adapters.flatMap((adapter) => {
+		return (adapter.hasOutput ? ["input", "output"] : ["input"]).map((kind) => ({
+			adapter,
+			kind
+		}));
+	}), ({ adapter, kind }) => bundleAdapterScript(adapter, kind, outputDir, tsconfig, cache));
+	const bundledInputs = /* @__PURE__ */ new Map();
+	const bundledOutputs = /* @__PURE__ */ new Map();
+	for (const [name, kind, code] of results) if (kind === "input") bundledInputs.set(name, code);
+	else bundledOutputs.set(name, code);
+	logger.log(`${styles.success("Bundled")} ${styles.info("\"http-adapter\"")}`);
+	return {
+		bundledInputs,
+		bundledOutputs
+	};
+}
+async function bundleAdapterScript(adapter, kind, outputDir, tsconfig, cache) {
+	const contextHash = computeBundlerContextHash({
+		sourceFile: adapter.sourceFile,
+		serializedTriggerContext: kind === "input" ? adapter.methods.join(",") : "",
+		tsconfig,
+		inlineSourcemap: false,
+		prefix: kind
+	});
+	const code = await withCache({
+		cache,
+		kind: kind === "input" ? "http-adapter-input" : "http-adapter-output",
+		name: adapter.name,
+		sourceFile: adapter.sourceFile,
+		contextHash,
+		async build(cachePlugins) {
+			const entryPath = path.join(outputDir, `${adapter.name}.${kind}.entry.js`);
+			const absoluteSourcePath = path.resolve(adapter.sourceFile);
+			const entryContent = kind === "input" ? buildInputEntry(absoluteSourcePath, adapter.methods) : buildOutputEntry(absoluteSourcePath);
+			fs$1.writeFileSync(entryPath, entryContent);
+			const plugins = [
+				{
+					name: "http-adapter-reject-node-imports",
+					resolveId(source) {
+						if (isNodeBuiltinImport(source)) throw new Error(`HTTP adapter "${adapter.name}" imports Node module "${source}", which is unavailable in the gateway runtime`);
+						return null;
+					}
+				},
+				{
+					name: "http-adapter-stub-sdk",
+					resolveId(source) {
+						if (source === "@tailor-platform/sdk" || source.startsWith("@tailor-platform/sdk/")) return {
+							id: "\0http-adapter-sdk-stub",
+							moduleSideEffects: false
+						};
+						return null;
+					},
+					load(id) {
+						if (id === "\0http-adapter-sdk-stub") return "export const createHttpAdapter = (cfg) => cfg;\nexport default { createHttpAdapter };\n";
+						return null;
+					}
+				},
+				...cachePlugins
+			];
+			let bundled;
+			try {
+				bundled = (await rolldown.build({
+					input: entryPath,
+					write: false,
+					output: {
+						format: "iife",
+						sourcemap: false,
+						minify: true,
+						codeSplitting: false
+					},
+					tsconfig,
+					plugins,
+					transform: { target: "es2017" },
+					treeshake: {
+						moduleSideEffects: false,
+						annotations: true,
+						unknownGlobalSideEffects: false
+					},
+					logLevel: "silent"
+				})).output[0].code;
+			} finally {
+				try {
+					fs$1.rmSync(entryPath, { force: true });
+				} catch {}
+			}
+			const byteLength = Buffer.byteLength(bundled, "utf8");
+			if (byteLength > ADAPTER_BUNDLE_ERROR_BYTES) throw new Error(`HTTP adapter "${adapter.name}" ${kind} script is ${byteLength} bytes, exceeding the ${ADAPTER_BUNDLE_ERROR_BYTES} byte limit`);
+			if (byteLength > ADAPTER_BUNDLE_WARN_BYTES) logger.warn(`HTTP adapter "${adapter.name}" ${kind} script is ${byteLength} bytes, larger than the recommended ${ADAPTER_BUNDLE_WARN_BYTES} byte limit`);
+			rejectAsyncInBundle(bundled, adapter.name, kind);
+			return bundled;
+		}
+	});
+	return [
+		adapter.name,
+		kind,
+		code
+	];
+}
+function buildInputEntry(absoluteSourcePath, methods) {
+	const cases = methods.map((method) => `    case "${HTTP_METHODS[method]}": return __adapter.input.${method}(req);`).join("\n");
+	const supported = methods.map((m) => HTTP_METHODS[m]).join(", ");
+	return `import __adapter from ${JSON.stringify(absoluteSourcePath)};
+globalThis.transform = function(req) {
+  switch (req.method) {
+${cases}
+    default: throw new Error("HTTP adapter received unsupported method: " + req.method + " (supported: ${supported})");
+  }
+};
+`;
+}
+function buildOutputEntry(absoluteSourcePath) {
+	return `import __adapter from ${JSON.stringify(absoluteSourcePath)};
+globalThis.transform = __adapter.output;
+`;
+}
+function rejectAsyncInBundle(code, adapterName, kind) {
+	const { program } = parseSync(`${adapterName}.${kind}.bundle.js`, code);
+	let asyncFound = false;
+	const stack = [program];
+	while (stack.length > 0) {
+		const node = stack.pop();
+		if (!node || typeof node !== "object") continue;
+		const n = node;
+		const type = typeof n.type === "string" ? n.type : "";
+		if (type === "AwaitExpression") {
+			asyncFound = true;
+			break;
+		}
+		if ((type === "FunctionDeclaration" || type === "FunctionExpression" || type === "ArrowFunctionExpression") && n.async === true) {
+			asyncFound = true;
+			break;
+		}
+		if ((type === "ForOfStatement" || type === "ForStatement") && n.await === true) {
+			asyncFound = true;
+			break;
+		}
+		for (const key of Object.keys(n)) {
+			const child = n[key];
+			if (Array.isArray(child)) for (const c of child) stack.push(c);
+			else if (child && typeof child === "object") stack.push(child);
+		}
+	}
+	if (asyncFound) throw new Error(`HTTP adapter "${adapterName}" ${kind} bundle contains async/await, which is unavailable in the gateway runtime. Check imported helper modules — even if your handler is synchronous, an async helper will fail at runtime.`);
+}
+
+//#endregion
+//#region src/cli/services/http-adapter/service.ts
+function createHttpAdapterService(params) {
+	const { config } = params;
+	let adapters = [];
+	let fileCount = 0;
+	let loaded = false;
+	return {
+		config,
+		get adapters() {
+			return adapters;
+		},
+		get fileCount() {
+			return fileCount;
+		},
+		loadAdapters: async () => {
+			if (loaded) return;
+			const result = await loadAdapterFiles(config);
+			adapters = result.adapters;
+			fileCount = result.fileCount;
+			loaded = true;
+		},
+		printLoadedAdapters: () => {
+			if (adapters.length === 0) return;
+			logger.newline();
+			logger.log(`Found ${styles.highlight(adapters.length.toString())} HTTP adapters`);
+			for (const { adapter, sourceFile } of adapters) {
+				const relativePath = path.relative(process.cwd(), sourceFile);
+				logger.log(`HTTP adapter: ${styles.successBright(`"${adapter.name}"`)} loaded from ${styles.path(relativePath)}`);
+			}
+		}
+	};
+}
+async function loadAdapterFiles(config) {
+	if (!config.files || config.files.length === 0) return {
+		adapters: [],
+		fileCount: 0
+	};
+	const files = loadFilesWithIgnores(config);
+	const loadResults = await Promise.all(files.map(loadAdapterFromFile));
+	const adapters = [];
+	const seenNames = /* @__PURE__ */ new Map();
+	for (const result of loadResults) {
+		if (!result) continue;
+		const existing = seenNames.get(result.adapter.name);
+		if (existing) throw new Error(`Duplicate HTTP adapter name "${result.adapter.name}" found:\n  - ${existing}\n  - ${result.sourceFile}\nEach HTTP adapter must have a unique name.`);
+		seenNames.set(result.adapter.name, result.sourceFile);
+		adapters.push(result);
+	}
+	return {
+		adapters,
+		fileCount: files.length
+	};
+}
+async function loadAdapterFromFile(filePath) {
+	try {
+		const module = await import(pathToFileURL(filePath).href);
+		if (!isSdkBranded(module.default, "http-adapter")) {
+			const named = Object.entries(module).find(([exportName, value]) => exportName !== "default" && isSdkBranded(value, "http-adapter"));
+			if (named) throw new Error(`HTTP adapter must be the default export, but it is exported as \`${named[0]}\`. Re-export it: \`export default createHttpAdapter({...})\`.`);
+			return null;
+		}
+		const parsed = HttpAdapterConfigSchema.safeParse(module.default);
+		if (!parsed.success) throw parsed.error;
+		const adapter = parsed.data;
+		const methods = collectMethodKeys(adapter);
+		rejectAsyncHandlers(adapter, methods, filePath);
+		return {
+			adapter,
+			sourceFile: filePath,
+			methods,
+			hasOutput: adapter.output !== void 0
+		};
+	} catch (error) {
+		const relativePath = path.relative(process.cwd(), filePath);
+		logger.error(`${styles.error("Failed to load HTTP adapter from")} ${styles.errorBright(relativePath)}`);
+		logger.error(String(error));
+		throw error;
+	}
+}
+function collectMethodKeys(adapter) {
+	const input = adapter.input;
+	return HTTP_METHOD_KEYS.filter((key) => typeof input[key] === "function");
+}
+function rejectAsyncHandlers(adapter, methods, sourceFile) {
+	const input = adapter.input;
+	for (const method of methods) if (isAsyncFunction(input[method])) throw new Error(`HTTP adapter "${adapter.name}" in ${sourceFile} has an async \`input.${method}\` function. Handlers must be synchronous; async/await is not supported.`);
+	if (adapter.output !== void 0 && isAsyncFunction(adapter.output)) throw new Error(`HTTP adapter "${adapter.name}" in ${sourceFile} has an async \`output\` function. Handlers must be synchronous; async/await is not supported.`);
+}
+function isAsyncFunction(fn) {
+	return typeof fn === "function" && fn.constructor?.name === "AsyncFunction";
+}
+
 //#endregion
 //#region src/parser/service/resolver/schema.ts
 const QueryTypeSchema = z.union([z.literal("query"), z.literal("mutation")]).describe("GraphQL operation type");
@@ -5181,6 +5491,10 @@ function defineWorkflow(config) {
 	if (!config) return;
 	return createWorkflowService({ config });
 }
+function defineHttpAdapterService(config) {
+	if (!config) return;
+	return createHttpAdapterService({ config });
+}
 function defineStaticWebsites(websites) {
 	const staticWebsiteServices = [];
 	const websiteNames = /* @__PURE__ */ new Set();
@@ -5249,6 +5563,7 @@ function buildApplication(params) {
 		authService: params.authResult.authService,
 		executorService: params.executorService,
 		workflowService: params.workflowService,
+		httpAdapterService: params.httpAdapterService,
 		staticWebsiteServices: params.staticWebsiteServices,
 		secrets: params.secrets,
 		ignoreNullishValues: params.ignoreNullishValues,
@@ -5271,11 +5586,13 @@ function defineApplication(params) {
 	const services = defineServices(config, pluginManager);
 	const executorService = defineExecutor(config.executor, false);
 	const workflowService = defineWorkflow(config.workflow);
+	const httpAdapterService = defineHttpAdapterService(config.httpAdapter);
 	return buildApplication({
 		config,
 		...services,
 		executorService,
 		workflowService,
+		httpAdapterService,
 		env: config.env ?? {}
 	});
 }
@@ -5323,6 +5640,8 @@ async function loadApplication(params) {
 	const executorService = defineExecutor(config.executor, pluginExecutorFiles.length > 0);
 	const workflowService = defineWorkflow(config.workflow);
 	if (workflowService) await workflowService.loadWorkflows();
+	const httpAdapterService = defineHttpAdapterService(config.httpAdapter);
+	if (httpAdapterService) await httpAdapterService.loadAdapters();
 	const triggerContext = await buildTriggerContext(config.workflow, authResult.authService?.config.name);
 	const inlineSourcemap = resolveInlineSourcemap(config.inlineSourcemap);
 	const bundledScripts = {
@@ -5348,6 +5667,13 @@ async function loadApplication(params) {
 		workflowBuildResult = await bundleWorkflowJobs(workflowService.jobs, mainJobNames, config.env ?? {}, triggerContext, bundleCache, inlineSourcemap);
 		bundledScripts.workflowJobs = workflowBuildResult.bundledCode;
 	}
+	let httpAdapterBuildResult;
+	if (httpAdapterService && httpAdapterService.adapters.length > 0) httpAdapterBuildResult = await bundleHttpAdapters(httpAdapterService.adapters.map((a) => ({
+		name: a.adapter.name,
+		sourceFile: a.sourceFile,
+		methods: a.methods,
+		hasOutput: a.hasOutput
+	})), bundleCache);
 	if (authResult.authService?.config.hooks?.beforeLogin) {
 		const authName = authResult.authService.config.name;
 		bundledScripts.authHooks = await bundleAuthHooks({
@@ -5366,6 +5692,7 @@ async function loadApplication(params) {
 		if (pluginExecutorFiles.length > 0) await executorService.loadPluginExecutorFiles([...pluginExecutorFiles]);
 	}
 	if (workflowService) workflowService.printLoadedWorkflows();
+	if (httpAdapterService) httpAdapterService.printLoadedAdapters();
 	logger.newline();
 	return {
 		application: buildApplication({
@@ -5376,16 +5703,18 @@ async function loadApplication(params) {
 			authResult,
 			executorService,
 			workflowService,
+			httpAdapterService,
 			staticWebsiteServices,
 			secrets,
 			ignoreNullishValues,
 			env: config.env ?? {}
 		}),
 		workflowBuildResult,
+		httpAdapterBuildResult,
 		bundledScripts
 	};
 }
 
 //#endregion
-export { loadConfigPath as C, saveUserTokens as D, resolveTokens as E, writePlatformConfig as O, loadAccessToken as S, readPlatformConfig as T, getDistDir as _, WorkflowJobSchema as a, deleteUserTokens as b, ExecutorSchema as c, buildResolverOperationHookExpr as d, OAuth2ClientSchema as f, createBundleCache as g, loadFilesWithIgnores as h, resolveInlineSourcemap as i, INVOKER_EXPR as l, stringifyFunction as m, generatePluginFilesIfNeeded as n, ResolverSchema as o, TailorDBTypeSchema as p, loadApplication as r, createExecutorService as s, defineApplication as t, buildExecutorArgsExpr as u, hashFile as v, loadWorkspaceId as w, fetchLatestToken as x, loadConfig as y };
-//# sourceMappingURL=application-BfGje3iZ.mjs.map
+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