@tanstack/cli 0.0.6 → 0.0.8

package/dist/fetch-DhlVXS6S.mjs

@@ -0,0 +1,390 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { z } from "zod";
+import { homedir } from "node:os";
+
+//#region src/engine/types.ts
+const CategorySchema = z.enum([
+	"tanstack",
+	"database",
+	"orm",
+	"auth",
+	"deploy",
+	"tooling",
+	"monitoring",
+	"api",
+	"i18n",
+	"cms",
+	"other"
+]);
+const IntegrationTypeSchema = z.enum([
+	"integration",
+	"example",
+	"toolchain",
+	"deployment"
+]);
+const IntegrationPhaseSchema = z.enum([
+	"setup",
+	"integration",
+	"example"
+]);
+const RouterModeSchema = z.enum(["file-router", "code-router"]);
+const SelectOptionSchema = z.object({
+	type: z.literal("select"),
+	label: z.string(),
+	description: z.string().optional(),
+	default: z.string(),
+	options: z.array(z.object({
+		value: z.string(),
+		label: z.string()
+	}))
+});
+const BooleanOptionSchema = z.object({
+	type: z.literal("boolean"),
+	label: z.string(),
+	description: z.string().optional(),
+	default: z.boolean()
+});
+const StringOptionSchema = z.object({
+	type: z.literal("string"),
+	label: z.string(),
+	description: z.string().optional(),
+	default: z.string()
+});
+const IntegrationOptionSchema = z.discriminatedUnion("type", [
+	SelectOptionSchema,
+	BooleanOptionSchema,
+	StringOptionSchema
+]);
+const IntegrationOptionsSchema = z.record(z.string(), IntegrationOptionSchema);
+const HookTypeSchema = z.enum([
+	"header-user",
+	"provider",
+	"root-provider",
+	"layout",
+	"vite-plugin",
+	"devtools",
+	"entry-client"
+]);
+const HookSchema = z.object({
+	type: HookTypeSchema.optional(),
+	path: z.string().optional(),
+	jsName: z.string().optional(),
+	import: z.string().optional(),
+	code: z.string().optional()
+});
+const RouteSchema = z.object({
+	url: z.string().optional(),
+	name: z.string().optional(),
+	icon: z.string().optional(),
+	path: z.string(),
+	jsName: z.string(),
+	children: z.array(z.lazy(() => RouteSchema)).optional()
+});
+const EnvVarSchema = z.object({
+	name: z.string(),
+	description: z.string(),
+	required: z.boolean().optional(),
+	example: z.string().optional()
+});
+const CommandSchema = z.object({
+	command: z.string(),
+	args: z.array(z.string()).optional()
+});
+const IntegrationInfoSchema = z.object({
+	id: z.string().optional(),
+	name: z.string(),
+	description: z.string(),
+	author: z.string().optional(),
+	version: z.string().optional(),
+	link: z.string().optional(),
+	license: z.string().optional(),
+	warning: z.string().optional(),
+	type: IntegrationTypeSchema,
+	phase: IntegrationPhaseSchema,
+	category: CategorySchema.optional(),
+	modes: z.array(RouterModeSchema),
+	priority: z.number().optional(),
+	default: z.boolean().optional(),
+	requiresTailwind: z.boolean().optional(),
+	demoRequiresTailwind: z.boolean().optional(),
+	dependsOn: z.array(z.string()).optional(),
+	exclusive: z.array(z.string()).optional(),
+	partnerId: z.string().optional(),
+	options: IntegrationOptionsSchema.optional(),
+	hooks: z.array(HookSchema).optional(),
+	routes: z.array(RouteSchema).optional(),
+	packageAdditions: z.object({
+		dependencies: z.record(z.string(), z.string()).optional(),
+		devDependencies: z.record(z.string(), z.string()).optional(),
+		scripts: z.record(z.string(), z.string()).optional()
+	}).optional(),
+	shadcnComponents: z.array(z.string()).optional(),
+	gitignorePatterns: z.array(z.string()).optional(),
+	envVars: z.array(EnvVarSchema).optional(),
+	command: CommandSchema.optional(),
+	integrationSpecialSteps: z.array(z.string()).optional(),
+	createSpecialSteps: z.array(z.string()).optional(),
+	postInitSpecialSteps: z.array(z.string()).optional(),
+	smallLogo: z.string().optional(),
+	logo: z.string().optional(),
+	readme: z.string().optional()
+});
+const IntegrationCompiledSchema = IntegrationInfoSchema.extend({
+	id: z.string(),
+	files: z.record(z.string(), z.string()),
+	deletedFiles: z.array(z.string()).optional()
+});
+const CustomTemplateInfoSchema = z.object({
+	id: z.string().optional(),
+	name: z.string(),
+	description: z.string(),
+	framework: z.string(),
+	mode: RouterModeSchema,
+	typescript: z.boolean(),
+	tailwind: z.boolean(),
+	integrations: z.array(z.string()),
+	integrationOptions: z.record(z.string(), z.record(z.string(), z.unknown())).optional(),
+	banner: z.string().optional()
+});
+const CustomTemplateCompiledSchema = CustomTemplateInfoSchema.extend({ id: z.string() });
+const ManifestIntegrationSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string(),
+	type: IntegrationTypeSchema,
+	category: CategorySchema.optional(),
+	modes: z.array(RouterModeSchema),
+	dependsOn: z.array(z.string()).optional(),
+	exclusive: z.array(z.string()).optional(),
+	partnerId: z.string().optional(),
+	hasOptions: z.boolean().optional(),
+	link: z.string().optional(),
+	color: z.string().optional(),
+	requiresTailwind: z.boolean().optional(),
+	demoRequiresTailwind: z.boolean().optional()
+});
+const ManifestCustomTemplateSchema = z.object({
+	id: z.string(),
+	name: z.string(),
+	description: z.string(),
+	banner: z.string().optional(),
+	icon: z.string().optional(),
+	features: z.array(z.string()).optional()
+});
+const ManifestSchema = z.object({
+	version: z.string(),
+	generated: z.string(),
+	integrations: z.array(ManifestIntegrationSchema),
+	customTemplates: z.array(ManifestCustomTemplateSchema).optional()
+});
+
+//#endregion
+//#region src/cache/index.ts
+const CACHE_DIR = join(homedir(), ".tanstack", "cache");
+const DEFAULT_TTL_MS = 1440 * 60 * 1e3;
+function ensureCacheDir() {
+	if (!existsSync(CACHE_DIR)) mkdirSync(CACHE_DIR, { recursive: true });
+}
+function getCachePath(key) {
+	return join(CACHE_DIR, `${key.replace(/[^a-zA-Z0-9-_]/g, "_")}.json`);
+}
+function getCached(key) {
+	const cachePath = getCachePath(key);
+	if (!existsSync(cachePath)) return null;
+	try {
+		const raw = readFileSync(cachePath, "utf-8");
+		const entry = JSON.parse(raw);
+		if (Date.now() - entry.timestamp > entry.ttl) return null;
+		return entry.data;
+	} catch {
+		return null;
+	}
+}
+function setCache(key, data, ttlMs = DEFAULT_TTL_MS) {
+	ensureCacheDir();
+	const cachePath = getCachePath(key);
+	const entry = {
+		data,
+		timestamp: Date.now(),
+		ttl: ttlMs
+	};
+	writeFileSync(cachePath, JSON.stringify(entry, null, 2), "utf-8");
+}
+async function fetchWithCache(key, fetcher, ttlMs = DEFAULT_TTL_MS) {
+	const cached = getCached(key);
+	if (cached !== null) return cached;
+	const data = await fetcher();
+	setCache(key, data, ttlMs);
+	return data;
+}
+
+//#endregion
+//#region src/api/fetch.ts
+const GITHUB_RAW_BASE = "https://raw.githubusercontent.com/TanStack/cli/main/integrations";
+const CACHE_TTL_MS = 3600 * 1e3;
+const BINARY_EXTENSIONS = new Set([
+	".png",
+	".jpg",
+	".jpeg",
+	".gif",
+	".webp",
+	".ico",
+	".svg",
+	".woff",
+	".woff2",
+	".ttf",
+	".eot",
+	".otf",
+	".pdf",
+	".zip",
+	".tar",
+	".gz",
+	".mp3",
+	".mp4",
+	".wav",
+	".ogg",
+	".webm"
+]);
+const BINARY_PREFIX = "base64:";
+/**
+* Check if a file should be treated as binary based on extension
+*/
+function isBinaryFile(filePath) {
+	return BINARY_EXTENSIONS.has(extname(filePath).toLowerCase());
+}
+/**
+* Check if a path is a local directory
+*/
+function isLocalPath(path) {
+	return path.startsWith("/") || path.startsWith("./") || path.startsWith("..");
+}
+/**
+* Fetch the integration manifest from GitHub or local path (with caching for remote)
+*/
+async function fetchManifest(baseUrl = GITHUB_RAW_BASE) {
+	if (isLocalPath(baseUrl)) {
+		const manifestPath = join(baseUrl, "manifest.json");
+		if (!existsSync(manifestPath)) throw new Error(`Manifest not found at ${manifestPath}`);
+		const data = JSON.parse(readFileSync(manifestPath, "utf-8"));
+		return ManifestSchema.parse(data);
+	}
+	return fetchWithCache(`manifest_${baseUrl.replace(/[^a-zA-Z0-9]/g, "_")}`, async () => {
+		const url = `${baseUrl}/manifest.json`;
+		const response = await fetch(url);
+		if (!response.ok) throw new Error(`Failed to fetch manifest: ${response.statusText}`);
+		const data = await response.json();
+		return ManifestSchema.parse(data);
+	}, CACHE_TTL_MS);
+}
+/**
+* Fetch integration info.json from GitHub or local path (with caching for remote)
+*/
+async function fetchIntegrationInfo(integrationId, baseUrl = GITHUB_RAW_BASE) {
+	if (isLocalPath(baseUrl)) {
+		const infoPath = join(baseUrl, integrationId, "info.json");
+		if (!existsSync(infoPath)) throw new Error(`Integration info not found at ${infoPath}`);
+		const data = JSON.parse(readFileSync(infoPath, "utf-8"));
+		return IntegrationInfoSchema.parse(data);
+	}
+	return fetchWithCache(`integration_info_${integrationId}_${baseUrl.replace(/[^a-zA-Z0-9]/g, "_")}`, async () => {
+		const url = `${baseUrl}/${integrationId}/info.json`;
+		const response = await fetch(url);
+		if (!response.ok) throw new Error(`Failed to fetch integration ${integrationId}: ${response.statusText}`);
+		const data = await response.json();
+		return IntegrationInfoSchema.parse(data);
+	}, CACHE_TTL_MS);
+}
+/**
+* Recursively read all files from a directory
+* Binary files are read as base64 with a prefix marker
+*/
+function readDirRecursive(dir, basePath = "") {
+	const files = {};
+	if (!existsSync(dir)) return files;
+	for (const entry of readdirSync(dir)) {
+		const fullPath = join(dir, entry);
+		const relativePath = basePath ? `${basePath}/${entry}` : entry;
+		if (statSync(fullPath).isDirectory()) Object.assign(files, readDirRecursive(fullPath, relativePath));
+		else if (isBinaryFile(relativePath)) files[relativePath] = BINARY_PREFIX + readFileSync(fullPath).toString("base64");
+		else files[relativePath] = readFileSync(fullPath, "utf-8");
+	}
+	return files;
+}
+/**
+* Fetch all files for an integration from GitHub or local path (with caching for remote)
+*/
+async function fetchIntegrationFiles(integrationId, baseUrl = GITHUB_RAW_BASE) {
+	if (isLocalPath(baseUrl)) return readDirRecursive(join(baseUrl, integrationId, "assets"));
+	return fetchWithCache(`integration_files_${integrationId}_${baseUrl.replace(/[^a-zA-Z0-9]/g, "_")}`, async () => {
+		const filesUrl = `${baseUrl}/${integrationId}/files.json`;
+		const response = await fetch(filesUrl);
+		if (!response.ok) return {};
+		const fileList = await response.json();
+		const files = {};
+		await Promise.all(fileList.map(async (filePath) => {
+			const fileUrl = `${baseUrl}/${integrationId}/assets/${filePath}`;
+			const fileResponse = await fetch(fileUrl);
+			if (fileResponse.ok) if (isBinaryFile(filePath)) {
+				const buffer = await fileResponse.arrayBuffer();
+				files[filePath] = BINARY_PREFIX + Buffer.from(buffer).toString("base64");
+			} else files[filePath] = await fileResponse.text();
+		}));
+		return files;
+	}, CACHE_TTL_MS);
+}
+/**
+* Fetch integration package.json if it exists
+*/
+async function fetchIntegrationPackageJson(integrationId, baseUrl) {
+	if (isLocalPath(baseUrl)) {
+		const pkgPath = join(baseUrl, integrationId, "package.json");
+		if (existsSync(pkgPath)) return JSON.parse(readFileSync(pkgPath, "utf-8"));
+		return null;
+	}
+	const url = `${baseUrl}/${integrationId}/package.json`;
+	const response = await fetch(url);
+	if (!response.ok) return null;
+	return response.json();
+}
+/**
+* Fetch a complete compiled integration from GitHub
+*/
+async function fetchIntegration(integrationId, baseUrl = GITHUB_RAW_BASE) {
+	const [info, files, pkgJson] = await Promise.all([
+		fetchIntegrationInfo(integrationId, baseUrl),
+		fetchIntegrationFiles(integrationId, baseUrl),
+		fetchIntegrationPackageJson(integrationId, baseUrl)
+	]);
+	const packageAdditions = info.packageAdditions ?? {};
+	if (pkgJson) {
+		if (pkgJson.dependencies) packageAdditions.dependencies = {
+			...packageAdditions.dependencies,
+			...pkgJson.dependencies
+		};
+		if (pkgJson.devDependencies) packageAdditions.devDependencies = {
+			...packageAdditions.devDependencies,
+			...pkgJson.devDependencies
+		};
+		if (pkgJson.scripts) packageAdditions.scripts = {
+			...packageAdditions.scripts,
+			...pkgJson.scripts
+		};
+	}
+	return IntegrationCompiledSchema.parse({
+		...info,
+		id: integrationId,
+		files,
+		packageAdditions: Object.keys(packageAdditions).length > 0 ? packageAdditions : void 0,
+		deletedFiles: []
+	});
+}
+/**
+* Fetch multiple integrations in parallel
+*/
+async function fetchIntegrations(integrationIds, baseUrl = GITHUB_RAW_BASE) {
+	return Promise.all(integrationIds.map((id) => fetchIntegration(id, baseUrl)));
+}
+
+//#endregion
+export { RouterModeSchema as S, IntegrationPhaseSchema as _, fetchIntegrations as a, ManifestSchema as b, CommandSchema as c, EnvVarSchema as d, HookSchema as f, IntegrationOptionsSchema as g, IntegrationOptionSchema as h, fetchIntegrationInfo as i, CustomTemplateCompiledSchema as l, IntegrationInfoSchema as m, fetchIntegration as n, fetchManifest as o, IntegrationCompiledSchema as p, fetchIntegrationFiles as r, CategorySchema as s, BINARY_PREFIX as t, CustomTemplateInfoSchema as u, IntegrationTypeSchema as v, RouteSchema as x, ManifestIntegrationSchema as y };

package/dist/fetch-I_OVg8JX.mjs

@@ -0,0 +1,3 @@
+import { a as fetchIntegrations, i as fetchIntegrationInfo, n as fetchIntegration, o as fetchManifest, r as fetchIntegrationFiles, t as BINARY_PREFIX } from "./fetch-DhlVXS6S.mjs";
+
+export { BINARY_PREFIX };

package/dist/index.cjs

@@ -1,31 +1,32 @@
-const require_template = require('./template-Cup47s9h.cjs');
+const require_template = require('./template-lWrIZhCQ.cjs');
+const require_fetch = require('./fetch-DG5dLrsb.cjs');
 
 exports.CONFIG_FILE = require_template.CONFIG_FILE;
-exports.CategorySchema = require_template.CategorySchema;
-exports.CommandSchema = require_template.CommandSchema;
-exports.CustomTemplateCompiledSchema = require_template.CustomTemplateCompiledSchema;
-exports.CustomTemplateInfoSchema = require_template.CustomTemplateInfoSchema;
-exports.EnvVarSchema = require_template.EnvVarSchema;
-exports.HookSchema = require_template.HookSchema;
-exports.IntegrationCompiledSchema = require_template.IntegrationCompiledSchema;
-exports.IntegrationInfoSchema = require_template.IntegrationInfoSchema;
-exports.IntegrationOptionSchema = require_template.IntegrationOptionSchema;
-exports.IntegrationOptionsSchema = require_template.IntegrationOptionsSchema;
-exports.IntegrationPhaseSchema = require_template.IntegrationPhaseSchema;
-exports.IntegrationTypeSchema = require_template.IntegrationTypeSchema;
-exports.ManifestIntegrationSchema = require_template.ManifestIntegrationSchema;
-exports.ManifestSchema = require_template.ManifestSchema;
-exports.RouteSchema = require_template.RouteSchema;
-exports.RouterModeSchema = require_template.RouterModeSchema;
+exports.CategorySchema = require_fetch.CategorySchema;
+exports.CommandSchema = require_fetch.CommandSchema;
+exports.CustomTemplateCompiledSchema = require_fetch.CustomTemplateCompiledSchema;
+exports.CustomTemplateInfoSchema = require_fetch.CustomTemplateInfoSchema;
+exports.EnvVarSchema = require_fetch.EnvVarSchema;
+exports.HookSchema = require_fetch.HookSchema;
+exports.IntegrationCompiledSchema = require_fetch.IntegrationCompiledSchema;
+exports.IntegrationInfoSchema = require_fetch.IntegrationInfoSchema;
+exports.IntegrationOptionSchema = require_fetch.IntegrationOptionSchema;
+exports.IntegrationOptionsSchema = require_fetch.IntegrationOptionsSchema;
+exports.IntegrationPhaseSchema = require_fetch.IntegrationPhaseSchema;
+exports.IntegrationTypeSchema = require_fetch.IntegrationTypeSchema;
+exports.ManifestIntegrationSchema = require_fetch.ManifestIntegrationSchema;
+exports.ManifestSchema = require_fetch.ManifestSchema;
+exports.RouteSchema = require_fetch.RouteSchema;
+exports.RouterModeSchema = require_fetch.RouterModeSchema;
 exports.compile = require_template.compile;
 exports.compileIntegration = require_template.compileIntegration;
 exports.compileTemplate = require_template.compileTemplate;
 exports.compileWithAttribution = require_template.compileWithAttribution;
-exports.fetchIntegration = require_template.fetchIntegration;
-exports.fetchIntegrationFiles = require_template.fetchIntegrationFiles;
-exports.fetchIntegrationInfo = require_template.fetchIntegrationInfo;
-exports.fetchIntegrations = require_template.fetchIntegrations;
-exports.fetchManifest = require_template.fetchManifest;
+exports.fetchIntegration = require_fetch.fetchIntegration;
+exports.fetchIntegrationFiles = require_fetch.fetchIntegrationFiles;
+exports.fetchIntegrationInfo = require_fetch.fetchIntegrationInfo;
+exports.fetchIntegrations = require_fetch.fetchIntegrations;
+exports.fetchManifest = require_fetch.fetchManifest;
 exports.initIntegration = require_template.initIntegration;
 exports.initTemplate = require_template.initTemplate;
 exports.loadRemoteIntegration = require_template.loadRemoteIntegration;

package/dist/index.mjs

@@ -1,3 +1,4 @@
-import { A as writeConfigFile, C as IntegrationTypeSchema, D as RouterModeSchema, E as RouteSchema, M as compileWithAttribution, N as processTemplateFile, O as CONFIG_FILE, P as relativePath, S as IntegrationPhaseSchema, T as ManifestSchema, _ as HookSchema, a as initIntegration, b as IntegrationOptionSchema, c as fetchIntegrationFiles, d as fetchManifest, f as CategorySchema, g as EnvVarSchema, h as CustomTemplateInfoSchema, i as compileIntegration, j as compile, k as readConfigFile, l as fetchIntegrationInfo, m as CustomTemplateCompiledSchema, n as initTemplate, o as loadRemoteIntegration, p as CommandSchema, r as loadTemplate, s as fetchIntegration, t as compileTemplate, u as fetchIntegrations, v as IntegrationCompiledSchema, w as ManifestIntegrationSchema, x as IntegrationOptionsSchema, y as IntegrationInfoSchema } from "./template-CkAkdP8n.mjs";
+import { a as initIntegration, c as readConfigFile, d as compileWithAttribution, f as processTemplateFile, i as compileIntegration, l as writeConfigFile, n as initTemplate, o as loadRemoteIntegration, p as relativePath, r as loadTemplate, s as CONFIG_FILE, t as compileTemplate, u as compile } from "./template-Szi7-AZJ.mjs";
+import { S as RouterModeSchema, _ as IntegrationPhaseSchema, a as fetchIntegrations, b as ManifestSchema, c as CommandSchema, d as EnvVarSchema, f as HookSchema, g as IntegrationOptionsSchema, h as IntegrationOptionSchema, i as fetchIntegrationInfo, l as CustomTemplateCompiledSchema, m as IntegrationInfoSchema, n as fetchIntegration, o as fetchManifest, p as IntegrationCompiledSchema, r as fetchIntegrationFiles, s as CategorySchema, u as CustomTemplateInfoSchema, v as IntegrationTypeSchema, x as RouteSchema, y as ManifestIntegrationSchema } from "./fetch-DhlVXS6S.mjs";
 
 export { CONFIG_FILE, CategorySchema, CommandSchema, CustomTemplateCompiledSchema, CustomTemplateInfoSchema, EnvVarSchema, HookSchema, IntegrationCompiledSchema, IntegrationInfoSchema, IntegrationOptionSchema, IntegrationOptionsSchema, IntegrationPhaseSchema, IntegrationTypeSchema, ManifestIntegrationSchema, ManifestSchema, RouteSchema, RouterModeSchema, compile, compileIntegration, compileTemplate, compileWithAttribution, fetchIntegration, fetchIntegrationFiles, fetchIntegrationInfo, fetchIntegrations, fetchManifest, initIntegration, initTemplate, loadRemoteIntegration, loadTemplate, processTemplateFile, readConfigFile, relativePath, writeConfigFile };