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

package/dist/file-routes-Dtln0K66.mjs

@@ -0,0 +1,438 @@
+import { createRequire } from "node:module";
+import path from "node:path";
+import { access, mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import { z } from "zod";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { parseSync } from "vite";
+import { tmpdir } from "node:os";
+import { existsSync, watch } from "node:fs";
+//#region src/builder/upload-manifest.ts
+const tailorkitUploadManifestSchema = z.object({
+	assets: z.object({
+		client: z.literal("client/client.js"),
+		server: z.literal("server/server.js").optional(),
+		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()
+	}),
+	views: z.array(z.object({
+		slot: z.string().min(1).max(255),
+		path: z.string().startsWith("/").max(1024),
+		instances: z.literal(true).optional(),
+		disabled: z.literal(true).optional()
+	})).max(1e3).optional(),
+	version: z.literal(1)
+});
+const createTailorKitUploadManifest = (logos, server = false, views) => tailorkitUploadManifestSchema.parse({
+	assets: {
+		client: "client/client.js",
+		...server ? { server: "server/server.js" } : {},
+		...logos && Object.keys(logos).length > 0 ? { logos } : {}
+	},
+	views,
+	version: 1
+});
+//#endregion
+//#region src/builder/database-paths.ts
+function appDatabasePaths(root, migrations) {
+	return {
+		schema: path.join(root, "src/db/schema.ts"),
+		migrations: path.resolve(root, migrations ?? "./src/db/migrations")
+	};
+}
+//#endregion
+//#region src/builder/drizzle.ts
+/** Use the app's Drizzle version with explicit flags; no Drizzle config file is needed. */
+async function drizzleGenerateArguments(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/schema-check.ts
+const run = promisify(execFile);
+async function snapshot(directory) {
+	const latest = (await readdir(directory, { withFileTypes: true }).catch((error) => {
+		if (error.code === "ENOENT") return [];
+		throw error;
+	})).filter((entry) => entry.isDirectory()).map((entry) => entry.name).sort().at(-1);
+	if (!latest) return;
+	const filename = path.join(directory, latest, "snapshot.json");
+	const value = JSON.parse(await readFile(filename, "utf8"));
+	if (value.version !== "7" || value.dialect !== "sqlite" || !Array.isArray(value.ddl)) throw new Error(`Unsupported app schema snapshot: ${filename}. Use Drizzle Kit v1 SQLite migrations.`);
+	return value;
+}
+function canonical(value) {
+	if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+	if (value && typeof value === "object") return `{${Object.entries(value).sort(([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. */
+async function checkAppSchema(root, migrationsDirectory) {
+	const schema = appDatabasePaths(root).schema;
+	try {
+		await access(schema);
+	} catch (error) {
+		if (error.code === "ENOENT") 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,
+			timeout: 3e4,
+			maxBuffer: 1048576,
+			env: {
+				...process.env,
+				CI: "true"
+			}
+		}).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).sort();
+		const actual = (saved?.ddl ?? []).map(canonical).sort();
+		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, {
+			recursive: true,
+			force: 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"
+]);
+function createScope(parent, functionScope = false) {
+	return {
+		parent,
+		functionScope,
+		bindings: /* @__PURE__ */ new Map()
+	};
+}
+function 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 [];
+	}
+}
+function bind(node, scope) {
+	for (const name of bindingNames(node)) scope.bindings.set(name, "local");
+}
+function classScope(node, parent) {
+	if (node.type === "ClassDeclaration") bind(node.id, parent);
+	const scope = createScope(parent);
+	bind(node.id, scope);
+	return scope;
+}
+function resolve(scope, name) {
+	for (let current = scope; current; current = current.parent) if (current.bindings.has(name)) return current.bindings.get(name);
+}
+function childNodes(node) {
+	return Object.values(node).flatMap((value) => {
+		return (Array.isArray(value) ? value : [value]).filter((child) => !!child && typeof child === "object" && "type" in child);
+	});
+}
+function bindImports(node, scope) {
+	const sdk = node.importKind !== "type" && clientImports.has(String(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. */
+function callScopes(program) {
+	const scopes = /* @__PURE__ */ new WeakMap();
+	function 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));
+	}
+	function 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);
+	}
+	function visit(node, scope) {
+		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);
+	}
+	visit(program, createScope(void 0, true));
+	return scopes;
+}
+/** Recognize the same SDK calls in route inference and instance extraction. */
+function 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 clientRuntimeImport = "tailorkit:file-client-runtime";
+function 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) return;
+	return {
+		slot,
+		path: routePath(routeSegments.join("/").slice(0, -9), filename)
+	};
+}
+function 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("/")}`;
+}
+/** Fill missing defineView options before instance extraction, on both build sides. */
+function inferFileView(source, filename, root) {
+	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 = [];
+	function visit(node) {
+		if (isDefineViewCall(node)) {
+			const options = node.arguments[0];
+			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 (child && typeof child === "object" && "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;
+}
+async function discoverFileRoutes(root) {
+	const views = [];
+	const roots = [];
+	const layouts = [];
+	const slotsDir = path.join(root, "src/slots");
+	async function scan(directory, slot, prefix = "") {
+		const entries = await readdir(directory, { withFileTypes: true }).catch((error) => {
+			if (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 ? `${prefix}${entry.name}/` : "");
+			else if (entry.isFile() && 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,
+						slot,
+						path: name ? routePath(name, filename) : "/"
+					});
+				}
+			}
+		}
+	}
+	await scan(slotsDir);
+	const rootFile = path.join(root, "src/root.tsx");
+	return {
+		root: existsSync(rootFile) ? { filename: rootFile } : void 0,
+		roots,
+		layouts,
+		views
+	};
+}
+/** Root, layout, view and binding sources to check before deployment. */
+async function getClientSourceFiles(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] : []
+	];
+}
+async function fileClientSource(root) {
+	const discovered = await discoverFileRoutes(root);
+	const imports = [`import { createFileClient } from ${JSON.stringify(clientRuntimeImport)};`];
+	let index = 0;
+	function module(entry) {
+		const binding = `module${index++}`;
+		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. */
+async function createFileRouteEntry(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;
+	async function refresh() {
+		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 = pending.then(refresh);
+		}, 25);
+	}) : void 0;
+	return {
+		entry,
+		async close() {
+			closed = true;
+			if (timer) clearTimeout(timer);
+			watcher?.close();
+			try {
+				await pending;
+			} finally {
+				await rm(directory, {
+					recursive: true,
+					force: true
+				});
+			}
+		}
+	};
+}
+function fileRoutesPlugin(root) {
+	return {
+		name: "tailorkit-file-routes",
+		enforce: "pre",
+		async resolveId(id) {
+			if (id !== clientRuntimeImport) return;
+			const importer = path.join(root(), "src/root.tsx");
+			return 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, appDatabasePaths as c, inferFileView as i, createTailorKitUploadManifest as l, fileRoutesPlugin as n, checkAppSchema as o, getClientSourceFiles as r, drizzleGenerateArguments as s, createFileRouteEntry as t, tailorkitUploadManifestSchema 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