@tailorkit/vite 0.0.0-stage → 0.1.0-beta.32

package/dist/file-routes-CjOIw7fH.mjs

@@ -0,0 +1,454 @@
+import { createRequire } from "node:module";
+import { z } from "zod";
+import { execFile } from "node:child_process";
+import { access, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import { promisify } from "node:util";
+import { existsSync, watch } from "node:fs";
+import { parseSync } from "vite";
+//#region src/builder/upload-manifest.ts
+const tailorkitUploadManifestSchema = z.object({
+	assets: z.object({
+		client: z.literal("client/client.js"),
+		logos: z.object({
+			dark: z.string().regex(/^client\/logo-dark\.(?:png|svg|webp)$/u).optional(),
+			light: z.string().regex(/^client\/logo-light\.(?:png|svg|webp)$/u).optional()
+		}).optional(),
+		server: z.literal("server/server.js").optional()
+	}),
+	version: z.literal(1),
+	views: z.array(z.object({
+		disabled: z.literal(true).optional(),
+		instances: z.literal(true).optional(),
+		path: z.string().startsWith("/").max(1024),
+		slot: z.string().min(1).max(255)
+	})).max(1e3).optional()
+});
+const createTailorKitUploadManifest = (logos, server = false, views) => {
+	const assets = { client: "client/client.js" };
+	if (server) assets.server = "server/server.js";
+	if (logos && Object.keys(logos).length > 0) assets.logos = logos;
+	return tailorkitUploadManifestSchema.parse({
+		assets,
+		version: 1,
+		views
+	});
+};
+//#endregion
+//#region src/builder/database-paths.ts
+const appDatabasePaths = (root, migrations) => ({
+	migrations: path.resolve(root, migrations ?? "./src/db/migrations"),
+	schema: path.join(root, "src/db/schema.ts")
+});
+//#endregion
+//#region src/builder/drizzle.ts
+/** Use the app's Drizzle version with explicit flags; no Drizzle config file is needed. */
+const drizzleGenerateArguments = async (root, output, name) => {
+	const require = createRequire(path.join(root, "package.json"));
+	for (const directory of require.resolve.paths("drizzle-kit") ?? []) {
+		const cli = path.join(directory, "drizzle-kit/bin.cjs");
+		if (await access(cli).then(() => true).catch(() => false)) return [
+			"--preserve-symlinks-main",
+			cli,
+			"generate",
+			"--dialect",
+			"sqlite",
+			"--schema",
+			appDatabasePaths(root).schema,
+			"--out",
+			output,
+			...name === void 0 ? [] : ["--name", name]
+		];
+	}
+	throw new Error("Install drizzle-kit and drizzle-orm as dev dependencies, then run tailorkit db generate.");
+};
+//#endregion
+//#region src/builder/env.ts
+/** The builder forwards the app developer’s environment to build tools. */
+const getBuildEnvironment = () => process.env;
+//#endregion
+//#region src/builder/fs-errors.ts
+const isMissingFile = (cause) => cause !== null && typeof cause === "object" && "code" in cause && cause.code === "ENOENT";
+//#endregion
+//#region src/builder/schema-check.ts
+const isObjectValue$1 = (value) => typeof value === "object" && value !== null;
+const run = promisify(execFile);
+const snapshot = async (directory) => {
+	const latest = (await readdir(directory, { withFileTypes: true }).catch((error) => {
+		if (isMissingFile(error)) return [];
+		throw error;
+	})).filter((entry) => entry.isDirectory()).map((entry) => entry.name).toSorted().at(-1);
+	if (!(latest !== void 0 && latest !== null && latest !== "")) return;
+	const filename = path.join(directory, latest, "snapshot.json");
+	const parsed = z.object({
+		ddl: z.array(z.unknown()),
+		dialect: z.literal("sqlite"),
+		version: z.literal("7")
+	}).safeParse(JSON.parse(await readFile(filename, "utf-8")));
+	if (!parsed.success) throw new Error(`Unsupported app schema snapshot: ${filename}. Use Drizzle Kit v1 SQLite migrations.`);
+	return parsed.data;
+};
+const canonical = (value) => {
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	if (isObjectValue$1(value)) return `{${Object.entries(value).toSorted(([left], [right]) => left.localeCompare(right)).map(([key, item]) => `${JSON.stringify(key)}:${canonical(item)}`).join(",")}}`;
+	return JSON.stringify(value);
+};
+/** Generate a fresh snapshot with Drizzle in disposable storage, leaving committed history unchanged. */
+const checkAppSchema = async (root, migrationsDirectory) => {
+	const { schema } = appDatabasePaths(root);
+	try {
+		await access(schema);
+	} catch (error) {
+		if (isMissingFile(error)) return;
+		throw error;
+	}
+	const temporary = await mkdtemp(path.join(tmpdir(), "tailorkit-schema-check-"));
+	try {
+		const { stdout } = await run(process.execPath, await drizzleGenerateArguments(root, temporary), {
+			cwd: root,
+			env: {
+				...getBuildEnvironment(),
+				CI: "true"
+			},
+			maxBuffer: 1048576,
+			timeout: 3e4
+		}).catch((error) => {
+			throw new Error(`Could not check the app database schema with Drizzle Kit. Check ${path.relative(root, schema)} and your drizzle-kit/drizzle-orm dependencies.`, { cause: error });
+		});
+		const current = await snapshot(temporary);
+		if (!current && !stdout.includes("No schema changes")) throw new Error(`Drizzle Kit did not produce a schema snapshot. Check ${path.relative(root, schema)} and run tailorkit db generate.`);
+		const saved = await snapshot(migrationsDirectory);
+		const expected = (current?.ddl ?? []).map(canonical).toSorted();
+		const actual = (saved?.ddl ?? []).map(canonical).toSorted();
+		if (canonical(expected) !== canonical(actual)) throw new Error(`App database migrations are missing or out of sync with ${path.relative(root, schema)}. Run tailorkit db generate, commit the generated files in ${path.relative(root, migrationsDirectory)}, then build again.`);
+	} finally {
+		await rm(temporary, {
+			force: true,
+			recursive: true
+		});
+	}
+};
+//#endregion
+//#region src/builder/define-view.ts
+const clientImports = /* @__PURE__ */ new Set([
+	"tailorkit/client",
+	"tailorkit/app",
+	"tailorkit/app/client",
+	"@tailorkit/app/client",
+	"@tailorkit/app"
+]);
+const createScope = (parent, functionScope = false) => ({
+	bindings: /* @__PURE__ */ new Map(),
+	functionScope,
+	parent
+});
+const bindingNames = (node) => {
+	if (!node) return [];
+	switch (node.type) {
+		case "Identifier": return [node.name];
+		case "RestElement": return bindingNames(node.argument);
+		case "AssignmentPattern": return bindingNames(node.left);
+		case "ArrayPattern": return node.elements.flatMap(bindingNames);
+		case "ObjectPattern": return node.properties.flatMap((property) => bindingNames(property.type === "Property" ? property.value : property.argument));
+		case "TSParameterProperty": return bindingNames(node.parameter);
+		default: return [];
+	}
+};
+const bind = (node, scope) => {
+	for (const name of bindingNames(node)) scope.bindings.set(name, "local");
+};
+const classScope = (node, parent) => {
+	if (node.type === "ClassDeclaration") bind(node.id, parent);
+	const scope = createScope(parent);
+	bind(node.id, scope);
+	return scope;
+};
+const resolve = (scope, name) => {
+	for (let current = scope; current; current = current.parent) if (current.bindings.has(name)) return current.bindings.get(name);
+};
+const childNodes = (node) => Object.values(node).flatMap((value) => {
+	return (Array.isArray(value) ? value : [value]).filter((child) => child !== void 0 && child !== null && child !== false && child !== "" && child !== 0 && !Number.isNaN(child) && child !== 0n && typeof child === "object" && "type" in child);
+});
+const bindImports = (node, scope) => {
+	const sdk = node.importKind !== "type" && clientImports.has(node.source.value);
+	for (const specifier of node.specifiers) {
+		let binding = "local";
+		if (sdk && specifier.type === "ImportNamespaceSpecifier") binding = "namespace";
+		else if (sdk && specifier.type === "ImportSpecifier" && specifier.importKind !== "type" && specifier.imported.type === "Identifier" && specifier.imported.name === "defineView") binding = "view";
+		scope.bindings.set(specifier.local.name, binding);
+	}
+};
+/** Resolve SDK import bindings, including declarations hoisted past a call. */
+const callScopes = (program) => {
+	const scopes = /* @__PURE__ */ new WeakMap();
+	const bindVariables = (node, scope) => {
+		let target = scope;
+		if (node.kind === "var") while (!target.functionScope && target.parent) target = target.parent;
+		for (const declaration of node.declarations) bind(declaration.id, target);
+	};
+	const visit = (node, initialScope) => {
+		let scope = initialScope;
+		scopes.set(node, scope);
+		switch (node.type) {
+			case "ImportDeclaration":
+				bindImports(node, scope);
+				return;
+			case "VariableDeclaration":
+				bindVariables(node, scope);
+				break;
+			case "FunctionDeclaration":
+			case "FunctionExpression":
+			case "ArrowFunctionExpression":
+				visitFunction(node, scope);
+				return;
+			case "ClassDeclaration":
+			case "ClassExpression":
+				scope = classScope(node, scope);
+				break;
+			case "CatchClause":
+				scope = createScope(scope);
+				bind(node.param, scope);
+				break;
+			case "SwitchStatement":
+				visit(node.discriminant, scope);
+				scope = createScope(scope);
+				for (const branch of node.cases) visit(branch, scope);
+				return;
+			case "BlockStatement":
+			case "ForStatement":
+			case "ForInStatement":
+			case "ForOfStatement":
+				scope = createScope(scope);
+				break;
+			case "StaticBlock":
+			case "TSModuleBlock":
+				scope = createScope(scope, true);
+				break;
+			case "TSEnumDeclaration":
+			case "TSModuleDeclaration": bind(node.id, scope);
+		}
+		for (const child of childNodes(node)) visit(child, scope);
+	};
+	const visitFunction = (node, scope) => {
+		if (node.type === "FunctionDeclaration") bind(node.id, scope);
+		const parameters = createScope(scope, true);
+		if (node.type !== "ArrowFunctionExpression") bind(node.id, parameters);
+		for (const parameter of node.params) bind(parameter, parameters);
+		for (const parameter of node.params) visit(parameter, parameters);
+		if (node.body) visit(node.body, createScope(parameters, true));
+	};
+	visit(program, createScope(void 0, true));
+	return scopes;
+};
+/** Recognize the same SDK calls in route inference and instance extraction. */
+const createDefineViewMatcher = (program) => {
+	const scopes = callScopes(program);
+	return (node) => {
+		if (node.type !== "CallExpression") return false;
+		const { callee } = node;
+		const scope = scopes.get(node);
+		if (callee.type === "Identifier") return resolve(scope, callee.name) === "view";
+		if (callee.type !== "MemberExpression" || callee.object.type !== "Identifier" || resolve(scope, callee.object.name) !== "namespace") return false;
+		return callee.computed ? callee.property.type === "Literal" && callee.property.value === "defineView" : callee.property.type === "Identifier" && callee.property.name === "defineView";
+	};
+};
+//#endregion
+//#region src/builder/file-routes.ts
+const isObjectValue = (value) => typeof value === "object" && value !== null;
+const clientRuntimeImport = "tailorkit:file-client-runtime";
+const routePath = (name, filename) => {
+	const segments = name.split(/[./]/u);
+	if (segments.some((segment) => !segment || segment === "..")) throw new Error(`${filename} has an empty route segment. Use route.nested-route.view.tsx.`);
+	return `/${segments.join("/")}`;
+};
+const fileViewLocation = (filename, root) => {
+	const relative = path.relative(path.join(root, "src/slots"), filename).split(path.sep);
+	if (relative.length < 2 || relative[0] === ".." || !filename.endsWith(".view.tsx")) return;
+	const [slot, ...routeSegments] = relative;
+	if (!(slot !== void 0 && slot !== null && slot !== "")) return;
+	const basename = routeSegments.join("/").slice(0, -9);
+	return {
+		path: routePath(basename, filename),
+		slot
+	};
+};
+/** Fill missing defineView options before instance extraction, on both build sides. */
+const inferFileView = (initialSource, filename, root) => {
+	let source = initialSource;
+	const location = fileViewLocation(filename, root);
+	if (!location) return source;
+	const { slot, path: viewPath } = location;
+	const parsed = parseSync(filename, source);
+	if (parsed.errors.length) throw new Error(`${filename}: ${parsed.errors[0]?.message}`);
+	const isDefineViewCall = createDefineViewMatcher(parsed.program);
+	const edits = [];
+	const visit = (node) => {
+		if (isDefineViewCall(node)) {
+			const [options] = node.arguments;
+			if (options?.type !== "ObjectExpression") throw new Error(`${filename}: file views require defineView with an inline options object.`);
+			const properties = new Set(options.properties.flatMap((property) => {
+				if (property.type !== "Property" || property.computed) return [];
+				if (property.key.type === "Identifier") return [property.key.name];
+				if (property.key.type === "Literal") return [String(property.key.value)];
+				return [];
+			}));
+			const defaults = [properties.has("slot") ? "" : `slot: ${JSON.stringify(slot)},`, properties.has("view") ? "" : `view: ${JSON.stringify(viewPath)},`].join("");
+			if (defaults) edits.push({
+				position: options.start + 1,
+				text: defaults
+			});
+		}
+		for (const value of Object.values(node)) {
+			const children = Array.isArray(value) ? value : [value];
+			for (const child of children) if (isObjectValue(child) && Boolean(child) && "type" in child) visit(child);
+		}
+	};
+	visit(parsed.program);
+	for (const edit of edits.toSorted((a, b) => b.position - a.position)) source = source.slice(0, edit.position) + edit.text + source.slice(edit.position);
+	return source;
+};
+const discoverFileRoutes = async (root) => {
+	const views = [];
+	const roots = [];
+	const layouts = [];
+	const slotsDir = path.join(root, "src/slots");
+	const scan = async (directory, slot, prefix = "") => {
+		const entries = await (async () => {
+			try {
+				return await readdir(directory, { withFileTypes: true });
+			} catch (error) {
+				if (error instanceof Error && "code" in error && error.code === "ENOENT") return [];
+				throw error;
+			}
+		})();
+		for (const entry of entries.toSorted((a, b) => a.name.localeCompare(b.name))) {
+			const filename = path.join(directory, entry.name);
+			if (entry.isDirectory()) await scan(filename, slot ?? entry.name, slot !== void 0 && slot !== null && slot !== "" ? `${prefix}${entry.name}/` : "");
+			else if (entry.isFile() && slot !== void 0 && slot !== null && slot !== "") {
+				if (entry.name.endsWith(".view.tsx")) {
+					fileViewLocation(filename, root);
+					views.push({
+						filename,
+						slot
+					});
+				} else if (entry.name === "root.tsx" && !prefix) roots.push({
+					filename,
+					slot
+				});
+				else if (entry.name === "layout.tsx" || entry.name.endsWith(".layout.tsx")) {
+					const name = entry.name === "layout.tsx" ? prefix.replace(/\/$/u, "") : prefix + entry.name.slice(0, -11);
+					layouts.push({
+						filename,
+						path: name ? routePath(name, filename) : "/",
+						slot
+					});
+				}
+			}
+		}
+	};
+	await scan(slotsDir);
+	const rootFile = path.join(root, "src/root.tsx");
+	return {
+		layouts,
+		root: existsSync(rootFile) ? { filename: rootFile } : void 0,
+		roots,
+		views
+	};
+};
+/** Root, layout, view and binding sources to check before deployment. */
+const getClientSourceFiles = async (root) => {
+	const discovered = await discoverFileRoutes(root);
+	const bindings = path.join(root, "src/tailorkit.gen.ts");
+	return [
+		...discovered.root ? [discovered.root.filename] : [],
+		...discovered.roots.map((module) => module.filename),
+		...discovered.layouts.map((module) => module.filename),
+		...discovered.views.map((module) => module.filename),
+		...existsSync(bindings) ? [bindings] : []
+	];
+};
+const fileClientSource = async (root) => {
+	const discovered = await discoverFileRoutes(root);
+	const imports = [`import { createFileClient } from ${JSON.stringify(clientRuntimeImport)};`];
+	let index = 0;
+	const module = (entry) => {
+		const binding = `module${(index += 1) - 1}`;
+		imports.push(`import ${binding} from ${JSON.stringify(entry.filename)};`);
+		return `{ filename: ${JSON.stringify(path.relative(root, entry.filename))}, definition: ${binding}`;
+	};
+	const rootModule = discovered.root ? `${module(discovered.root)} }` : "undefined";
+	const roots = discovered.roots.map((entry) => `${module(entry)}, slot: ${JSON.stringify(entry.slot)} }`);
+	const layouts = discovered.layouts.map((entry) => `${module(entry)}, slot: ${JSON.stringify(entry.slot)}, path: ${JSON.stringify(entry.path)} }`);
+	const views = discovered.views.map((entry) => `${module(entry)}, slot: ${JSON.stringify(entry.slot)} }`);
+	return `${imports.join("\n")}\nexport default createFileClient({ root: ${rootModule}, roots: [${roots.join(",")}], layouts: [${layouts.join(",")}], views: [${views.join(",")}] });`;
+};
+/** A generated entry in build output lets the bundler track imports normally.
+* Directory watching also covers routes that did not exist at the first build. */
+const createFileRouteEntry = async (root, output, watching) => {
+	let source = await fileClientSource(root);
+	const temporaryRoot = path.join(output, "tmp");
+	await mkdir(temporaryRoot, { recursive: true });
+	const directory = await mkdtemp(path.join(temporaryRoot, "client-"));
+	const entry = path.join(directory, "entry.ts");
+	await writeFile(entry, source);
+	let pending = Promise.resolve();
+	let closed = false;
+	let timer;
+	const refresh = async () => {
+		if (closed) return;
+		let next;
+		try {
+			next = await fileClientSource(root);
+		} catch (error) {
+			next = `throw new Error(${JSON.stringify(error instanceof Error ? error.message : String(error))});`;
+		}
+		if (next === source) return;
+		source = next;
+		await writeFile(entry, next);
+	};
+	const watcher = watching ? watch(path.join(root, "src"), { recursive: true }, () => {
+		if (timer) clearTimeout(timer);
+		timer = setTimeout(() => {
+			pending = (async () => {
+				await pending;
+				await refresh();
+			})();
+		}, 25);
+	}) : void 0;
+	return {
+		close: async () => {
+			closed = true;
+			if (timer) clearTimeout(timer);
+			watcher?.close();
+			try {
+				await pending;
+			} finally {
+				await rm(directory, {
+					force: true,
+					recursive: true
+				});
+			}
+		},
+		entry
+	};
+};
+const fileRoutesPlugin = (root) => ({
+	enforce: "pre",
+	name: "tailorkit-file-routes",
+	async resolveId(id) {
+		if (id !== clientRuntimeImport) return;
+		const importer = path.join(root(), "src/root.tsx");
+		return await (await this.resolve("tailorkit/client", importer, { skipSelf: true }) ?? this.resolve("@tailorkit/app/client", importer, { skipSelf: true }));
+	},
+	transform: (source, filename) => {
+		if (!filename.endsWith(".view.tsx")) return;
+		const code = inferFileView(source, filename, root());
+		return code === source ? void 0 : {
+			code,
+			map: null
+		};
+	}
+});
+//#endregion
+export { createDefineViewMatcher as a, getBuildEnvironment as c, createTailorKitUploadManifest as d, tailorkitUploadManifestSchema as f, inferFileView as i, drizzleGenerateArguments as l, fileRoutesPlugin as n, checkAppSchema as o, getClientSourceFiles as r, isMissingFile as s, createFileRouteEntry as t, appDatabasePaths as u };

package/dist/index.d.mts

@@ -0,0 +1,9 @@
+import { Plugin } from "vite";
+//#region src/index.d.ts
+export interface TailorKitPluginOptions {
+  /** Config file path relative to vite.config.ts. Defaults to ./tailorkit.config.ts. */
+  configPath?: string;
+}
+/** Build the app client, private backend, migrations and deployment manifest. */
+export declare const tailorkit: (options?: TailorKitPluginOptions) => Plugin[];
+//#endregion