@softr/sdk 0.0.23 → 0.0.25

package/dist/routes/manifest.js

@@ -1,168 +0,0 @@
-import { crawlRoutes, extractDatasources, extractVisibility } from "./discover.js";
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { inferFullPath } from "@tanstack/router-generator";
-
-//#region src/routes/manifest.ts
-var ManifestError = class extends Error {
-	detail;
-	constructor(detail) {
-		super(detail.message);
-		this.name = "ManifestError";
-		this.detail = detail;
-	}
-};
-/** Returns the manifest as the exact text to write. Throws on a declaration it cannot read. */
-async function generateRoutesManifest(root) {
-	const crawl = await crawlRoutes({ root });
-	const routeFiles = new Set([crawl.rootRouteNode.filePath]);
-	for (const node of crawl.routeNodes) routeFiles.add(node.filePath);
-	for (const pieces of Object.values(crawl.routePiecesByPath)) if (pieces.lazy) routeFiles.add(pieces.lazy.filePath);
-	const sources = /* @__PURE__ */ new Map();
-	for (const relative of routeFiles) {
-		const absolute = path.resolve(root, crawl.routesDirectory, relative);
-		const source = await readIfPresent(absolute);
-		if (source !== null) sources.set(absolute, source);
-	}
-	const manifest = buildManifest({
-		crawl,
-		root,
-		sources
-	});
-	return `${JSON.stringify(manifest, null, 2)}\n`;
-}
-function buildManifest(opts) {
-	const routesDirectory = opts.crawl.routesDirectory;
-	const datasources = [];
-	const toNode = (node) => {
-		const projectRelative = toProjectRelative(opts.root, routesDirectory, node.filePath);
-		const routePath = node.routePath;
-		if (routePath === void 0) throw new Error(`the route crawl produced a node with no route path: ${projectRelative}`);
-		let declared = visibilityOf(opts, node.filePath);
-		datasources.push(...datasourceEntriesOf(opts, node.filePath, routePath));
-		const lazyPiece = opts.crawl.routePiecesByPath[routePath]?.lazy;
-		if (lazyPiece && lazyPiece.filePath !== node.filePath) {
-			const lazyDeclared = visibilityOf(opts, lazyPiece.filePath);
-			if (lazyDeclared !== null && declared !== null) throw new ManifestError({
-				code: "duplicate-declaration",
-				message: `${routePath} declares visibility in both ${projectRelative} and ${lazyDeclared.filePath}; a route has exactly one rule`,
-				filePath: lazyDeclared.filePath,
-				line: lazyDeclared.line,
-				column: lazyDeclared.column
-			});
-			if (lazyDeclared !== null) declared = lazyDeclared;
-			datasources.push(...datasourceEntriesOf(opts, lazyPiece.filePath, routePath));
-		}
-		return {
-			routePath,
-			filePath: projectRelative,
-			...node._fsRouteType ? { _fsRouteType: node._fsRouteType } : {},
-			inferFullPath: inferFullPath(node) ?? null,
-			createFileRouteProps: [...node.createFileRouteProps ?? []].sort(),
-			visibility: declared?.value ?? null,
-			children: (node.children ?? []).map(toNode)
-		};
-	};
-	const rootNode = opts.crawl.rootRouteNode;
-	const rootRelative = toProjectRelative(opts.root, routesDirectory, rootNode.filePath);
-	const rootDeclared = visibilityOf(opts, rootNode.filePath);
-	if (rootDeclared !== null) throw new ManifestError({
-		code: "root-declaration",
-		message: "the root route cannot carry a visibility rule: it would gate sign-in with no way back in. Move this declaration to the routes you want gated.",
-		filePath: rootRelative,
-		line: rootDeclared.line,
-		column: rootDeclared.column
-	});
-	datasources.push(...datasourceEntriesOf(opts, rootNode.filePath, ROOT_ROUTE_ID));
-	return {
-		root: {
-			routePath: ROOT_ROUTE_ID,
-			filePath: rootRelative,
-			inferFullPath: inferFullPath(rootNode) ?? null,
-			createFileRouteProps: [...rootNode.createFileRouteProps ?? []].sort(),
-			visibility: null,
-			children: opts.crawl.routeTree.map(toNode)
-		},
-		datasources
-	};
-}
-/**
-* `rootRouteId` from `@tanstack/router-core`, which is what a consumer matches against — not the
-* generator's `rootPathId`, which is the base name of `__root.tsx` and names a file, not a route.
-*/
-const ROOT_ROUTE_ID = "__root__";
-/** The crawl's paths are relative to the routes directory; the manifest's are project-relative. */
-function toProjectRelative(root, routesDirectory, filePath) {
-	const absolute = path.resolve(root, routesDirectory, filePath);
-	return path.relative(root, absolute).split(path.sep).join("/");
-}
-const USER_GROUPS = [
-	"ALL_USERS",
-	"NON_LOGGED_IN_USERS",
-	"LOGGED_IN_USERS"
-];
-function checkVisibilityShape(declared) {
-	const reject = (message) => {
-		throw new ManifestError({
-			code: "invalid-visibility",
-			message: `${declared.filePath}: ${message}`,
-			filePath: declared.filePath,
-			line: declared.line,
-			column: declared.column
-		});
-	};
-	const visibility = declared.value;
-	if (typeof visibility !== "object" || Array.isArray(visibility)) reject(`the visibility rule must be an object literal like { userGroup: 'ALL_USERS' }, not ${JSON.stringify(visibility)}`);
-	for (const key of Object.keys(visibility)) {
-		if (key === "userGroup" || key === "userGroupIds") continue;
-		reject(`"${key}" is not part of a visibility rule; a rule has userGroup and, under LOGGED_IN_USERS, userGroupIds. Check the spelling.`);
-	}
-	const userGroup = visibility["userGroup"];
-	if (typeof userGroup !== "string" || !USER_GROUPS.includes(userGroup)) reject(`userGroup must be one of ${USER_GROUPS.join(", ")}, not ${JSON.stringify(userGroup)}. A rule the build cannot read is a route with no rule at all.`);
-	if (!("userGroupIds" in visibility)) return;
-	if (userGroup !== "LOGGED_IN_USERS") reject(`userGroupIds only means anything under LOGGED_IN_USERS, not under ${userGroup}`);
-	const ids = visibility["userGroupIds"];
-	if (!Array.isArray(ids) || ids.some((id) => typeof id !== "string")) reject(`userGroupIds must be an array of group id strings, not ${JSON.stringify(ids)}. Drop the key entirely to mean "any logged-in user".`);
-}
-function visibilityOf(opts, filePath) {
-	const projectRelative = toProjectRelative(opts.root, opts.crawl.routesDirectory, filePath);
-	const source = opts.sources.get(path.resolve(opts.root, opts.crawl.routesDirectory, filePath));
-	if (source === void 0) return null;
-	const result = extractVisibility(source, projectRelative);
-	if (!result.ok) throw new ManifestError(result.error);
-	if (result.visibility === null) return null;
-	const declared = {
-		...result.visibility,
-		filePath: projectRelative
-	};
-	checkVisibilityShape(declared);
-	return declared;
-}
-function datasourceEntriesOf(opts, filePath, routePath) {
-	const projectRelative = toProjectRelative(opts.root, opts.crawl.routesDirectory, filePath);
-	const source = opts.sources.get(path.resolve(opts.root, opts.crawl.routesDirectory, filePath));
-	if (source === void 0) return [];
-	const result = extractDatasources(source, projectRelative);
-	if (!result.ok) throw new ManifestError(result.error);
-	return result.datasources.map(({ id, methods }) => ({
-		id,
-		methods,
-		filename: projectRelative,
-		route: routePath
-	}));
-}
-/**
-* Only ENOENT becomes `null`. The caller reads `null` as "nothing declared here", so swallowing any
-* other read error would turn an unreadable declaration into an ungated route.
-*/
-async function readIfPresent(filePath) {
-	try {
-		return await readFile(filePath, "utf8");
-	} catch (error) {
-		if (error.code === "ENOENT") return null;
-		throw error;
-	}
-}
-
-//#endregion
-export { ManifestError, generateRoutesManifest };

package/dist/routes/mem-fs.js

@@ -1,71 +0,0 @@
-import * as nodeFs from "node:fs/promises";
-import path from "node:path";
-
-//#region src/routes/mem-fs.ts
-/**
-* Reads through to disk and swallows every write. Driving the generator without this rewrites the
-* app's route sources and strips Start's `Register` block from its routeTree.gen.ts.
-*/
-function createReadOnlyFs() {
-	const writes = /* @__PURE__ */ new Map();
-	return {
-		async stat(filePath) {
-			const stat = await statOrNull(path.resolve(filePath));
-			if (stat === null) return {
-				mtimeMs: SYNTHETIC_MTIME,
-				mode: 420,
-				uid: 0,
-				gid: 0
-			};
-			return {
-				mtimeMs: stat.mtimeMs,
-				mode: Number(stat.mode),
-				uid: Number(stat.uid),
-				gid: Number(stat.gid)
-			};
-		},
-		async rename(oldPath, newPath) {
-			const from = path.resolve(oldPath);
-			const content = writes.get(from);
-			if (content !== void 0) {
-				writes.delete(from);
-				writes.set(path.resolve(newPath), content);
-			}
-		},
-		async writeFile(filePath, content) {
-			writes.set(path.resolve(filePath), content);
-		},
-		async readFile(filePath) {
-			const resolved = path.resolve(filePath);
-			const pending = writes.get(resolved);
-			const stat = await statOrNull(resolved);
-			if (pending !== void 0) return {
-				stat: { mtimeMs: stat?.mtimeMs ?? SYNTHETIC_MTIME },
-				fileContent: pending
-			};
-			if (stat === null) return "file-not-existing";
-			try {
-				const fileContent = await nodeFs.readFile(resolved, "utf8");
-				return {
-					stat: { mtimeMs: stat.mtimeMs },
-					fileContent
-				};
-			} catch {
-				return "file-not-existing";
-			}
-		},
-		async chmod() {},
-		async chown() {}
-	};
-}
-const SYNTHETIC_MTIME = 1n;
-async function statOrNull(filePath) {
-	try {
-		return await nodeFs.stat(filePath, { bigint: true });
-	} catch {
-		return null;
-	}
-}
-
-//#endregion
-export { createReadOnlyFs };