@tailor-platform/sdk 1.2.6 → 1.4.0

package/dist/cli/index.mjs

@@ -1,17 +1,19 @@
 #!/usr/bin/env node
 import "../chunk-CIV_ash9.mjs";
-import "../config-BmQRlW1j.mjs";
-import { $ as withCommonArgs, B as loadWorkspaceId, D as tokenCommand, F as loadConfig, G as initOAuth2Client, H as writePlatformConfig, J as PATScope, K as initOperatorClient, L as apiCommand, N as applyCommand, O as listCommand$5, Q as jsonArgs, R as fetchLatestToken, S as listCommand$6, U as fetchAll, V as readPlatformConfig, W as fetchUserInfo, X as confirmationArgs, Y as commonArgs, Z as deploymentArgs, a as createCommand$3, d as listCommand$7, et as workspaceArgs, h as executionsCommand, j as generateCommand, l as startCommand, p as getCommand$2, q as readPackageJson, r as deleteCommand$3, s as resumeCommand, t as listCommand$8, tt as logger, w as getCommand$1, x as removeCommand, y as showCommand, z as loadAccessToken } from "../list-WMFoshbx.mjs";
-import { register } from "node:module";
+import "../config-CBpYlVa-.mjs";
+import { $ as deploymentArgs, A as listCommand$5, B as fetchLatestToken, C as removeCommand, E as getCommand$1, F as applyCommand, G as fetchAll, H as loadWorkspaceId, J as initOperatorClient, K as fetchUserInfo, L as loadConfig, N as generateCommand, Q as confirmationArgs, U as readPlatformConfig, V as loadAccessToken, W as writePlatformConfig, X as PATScope, Y as readPackageJson, Z as commonArgs, a as createCommand$3, d as listCommand$7, et as jsonArgs, h as executionsCommand, k as tokenCommand, l as startCommand, nt as workspaceArgs, p as getCommand$2, q as initOAuth2Client, r as deleteCommand$3, rt as logger, s as resumeCommand, t as listCommand$8, tt as withCommonArgs, w as listCommand$6, x as showCommand, y as truncateCommand, z as apiCommand } from "../list-1cs_CGF8.mjs";
+import { createRequire, register } from "node:module";
 import { defineCommand, runCommand, runMain } from "citty";
+import * as fs$1 from "node:fs";
+import * as path from "pathe";
 import { generateCodeVerifier } from "@badgateway/oauth2-client";
 import { timestampDate } from "@bufbuild/protobuf/wkt";
 import { Code, ConnectError } from "@connectrpc/connect";
+import { findUpSync } from "find-up-simple";
 import ml from "multiline-ts";
-import * as path from "path";
-import * as fs from "fs";
+import * as fs$2 from "fs";
 import pLimit from "p-limit";
-import { spawnSync } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
 import * as crypto from "node:crypto";
 import * as http from "node:http";
 import open from "open";
@@ -55,7 +57,7 @@ const initCommand = defineCommand({
 		const version = packageJson$1.version && packageJson$1.version !== "0.0.0" ? packageJson$1.version : "latest";
 		let packageManager = detectPackageManager();
 		if (!packageManager) {
-			logger.warn("⚠️ Could not detect package manager, defaulting to npm");
+			logger.warn("Could not detect package manager, defaulting to npm");
 			packageManager = "npm";
 		}
 		const initArgs = [
@@ -516,8 +518,8 @@ function secretInfo(secret) {
 }
 /**
 * List secrets in a Secret Manager vault.
-* @param {SecretListOptions} options - Secret listing options
-* @returns {Promise<SecretInfo[]>} List of secrets
+* @param options - Secret listing options
+* @returns List of secrets
 */
 async function secretList(options) {
 	const client = await initOperatorClient(await loadAccessToken({
@@ -693,8 +695,8 @@ function vaultInfo(vault) {
 }
 /**
 * List Secret Manager vaults in the workspace.
-* @param {VaultListOptions} [options] - Vault listing options
-* @returns {Promise<VaultInfo[]>} List of vaults
+* @param options - Vault listing options
+* @returns List of vaults
 */
 async function vaultList(options) {
 	const client = await initOperatorClient(await loadAccessToken({
@@ -772,9 +774,9 @@ const secretCommand = defineCommand({
 //#region src/cli/utils/progress.ts
 /**
 * Create a simple progress reporter that writes updates to stderr.
-* @param {string} label - Label to prefix progress output
-* @param {number} total - Total number of steps
-* @returns {{ update: () => void; finish: () => void }} Progress helpers
+* @param label - Label to prefix progress output
+* @param total - Total number of steps
+* @returns Progress helpers
 */
 function createProgress(label, total) {
 	let current = 0;
@@ -794,10 +796,10 @@ function createProgress(label, total) {
 /**
 * Wrap a promise with a timeout, rejecting if the timeout elapses first.
 * @template T
-* @param {Promise<T>} p - Promise to await
-* @param {number} ms - Timeout in milliseconds
-* @param {string} message - Error message on timeout
-* @returns {Promise<T>} Result of the original promise if it completes in time
+* @param p - Promise to await
+* @param ms - Timeout in milliseconds
+* @param message - Error message on timeout
+* @returns Result of the original promise if it completes in time
 */
 async function withTimeout(p, ms, message) {
 	return await Promise.race([p, setTimeout$1(ms).then(() => {
@@ -817,6 +819,15 @@ function shouldIgnoreFile(filePath) {
 	const fileName = path.basename(filePath).toLowerCase();
 	return IGNORED_FILES.has(fileName);
 }
+/**
+* Deploy a static website by creating a deployment, uploading files, and publishing it.
+* @param client - Operator client instance
+* @param workspaceId - Workspace ID
+* @param name - Static website name
+* @param distDir - Directory containing static site files
+* @param showProgress - Whether to show upload progress
+* @returns Deployment result with URL and skipped files
+*/
 async function deployStaticWebsite(client, workspaceId, name, distDir, showProgress = true) {
 	const { deploymentId } = await client.createDeployment({
 		workspaceId,
@@ -851,9 +862,15 @@ async function uploadDirectory(client, workspaceId, deploymentId, rootDir, showP
 	if (progress) progress.finish();
 	return skippedFiles;
 }
+/**
+* Recursively collect all deployable files under the given directory.
+* @param rootDir - Root directory to scan
+* @param currentDir - Current relative directory (for recursion)
+* @returns List of file paths relative to rootDir
+*/
 async function collectFiles(rootDir, currentDir = "") {
 	const dirPath = path.join(rootDir, currentDir);
-	const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+	const entries = await fs$2.promises.readdir(dirPath, { withFileTypes: true });
 	const files = [];
 	for (const entry of entries) {
 		const rel = path.join(currentDir, entry.name);
@@ -864,16 +881,15 @@ async function collectFiles(rootDir, currentDir = "") {
 	}
 	return files;
 }
-async function uploadSingleFile(client, workspaceId, deploymentId, rootDir, relativePath, skippedFiles) {
-	const absPath = path.join(rootDir, relativePath);
-	const filePath = relativePath.split(path.sep).join("/");
+async function uploadSingleFile(client, workspaceId, deploymentId, rootDir, filePath, skippedFiles) {
+	const absPath = path.join(rootDir, filePath);
 	const mime = lookup(filePath);
 	if (!mime) {
 		skippedFiles.push(`${filePath} (unsupported content type; no MIME mapping found)`);
 		return;
 	}
 	const contentType = mime;
-	const readStream = fs.createReadStream(absPath, { highWaterMark: CHUNK_SIZE });
+	const readStream = fs$2.createReadStream(absPath, { highWaterMark: CHUNK_SIZE });
 	async function* requestStream() {
 		yield { payload: {
 			case: "initialMetadata",
@@ -902,6 +918,10 @@ async function uploadSingleFile(client, workspaceId, deploymentId, rootDir, rela
 	}
 	await withTimeout(uploadWithLogging(), 2 * 6e4, `Upload timed out for "${filePath}"`);
 }
+/**
+* Log skipped files after a deployment, including reasons for skipping.
+* @param skippedFiles - List of skipped file descriptions
+*/
 function logSkippedFiles(skippedFiles) {
 	if (skippedFiles.length === 0) return;
 	logger.warn("Deployment completed, but some files failed to upload. These files may have unsupported content types or other validation issues. Please review the list below:");
@@ -941,7 +961,7 @@ const deployCommand = defineCommand({
 			workspaceId: args["workspace-id"],
 			profile: args.profile
 		});
-		if (!fs.existsSync(dir) || !fs.statSync(dir).isDirectory()) throw new Error(`Directory not found or not a directory: ${dir}`);
+		if (!fs$2.existsSync(dir) || !fs$2.statSync(dir).isDirectory()) throw new Error(`Directory not found or not a directory: ${dir}`);
 		const { url, skippedFiles } = await withTimeout(deployStaticWebsite(client, workspaceId, name, dir, !args.json), 10 * 6e4, "Deployment timed out after 10 minutes.");
 		if (args.json) logger.out({
 			name,
@@ -1008,10 +1028,8 @@ const getCommand = defineCommand({
 //#region src/cli/staticwebsite/list.ts
 /**
 * List static websites in the workspace.
-* @param {{ workspaceId?: string; profile?: string }} [options] - Static website listing options
-* @param {string} [options.workspaceId] - Workspace ID
-* @param {string} [options.profile] - Workspace profile
-* @returns {Promise<StaticWebsiteInfo[]>} List of static websites
+* @param options - Static website listing options
+* @returns List of static websites
 */
 async function listStaticWebsites(options) {
 	const client = await initOperatorClient(await loadAccessToken({
@@ -1085,176 +1103,515 @@ const staticwebsiteCommand = defineCommand({
 });
 
 //#endregion
-//#region src/cli/tailordb/truncate.ts
-async function truncateSingleType(options, client) {
-	await client.truncateTailorDBType({
-		workspaceId: options.workspaceId,
-		namespaceName: options.namespaceName,
-		tailordbTypeName: options.typeName
+//#region src/cli/utils/resolve-cli-bin.ts
+/**
+* Resolve a CLI binary path from the caller's project dependencies.
+* @param options - Resolution options for locating the CLI binary.
+* @returns Absolute path to the CLI binary entry.
+*/
+function resolveCliBinPath(options) {
+	const { cwd, packageName, binName, installHint } = options;
+	const projectPackageJsonPath = findUpSync("package.json", { cwd });
+	if (!projectPackageJsonPath) throw new Error(`Failed to locate package.json from ${cwd}.`);
+	const requireFromProject = createRequire(projectPackageJsonPath);
+	let pkgJsonPath;
+	try {
+		pkgJsonPath = requireFromProject.resolve(`${packageName}/package.json`);
+	} catch {
+		throw new Error(`Missing optional dependency \`${packageName}\`. Install it in your project (e.g. \`${installHint}\`).`);
+	}
+	const binRelativePath = JSON.parse(fs$1.readFileSync(pkgJsonPath, "utf8")).bin?.[binName];
+	if (!binRelativePath) throw new Error(`\`${packageName}\` does not expose a \`${binName}\` binary entry.`);
+	return path.resolve(path.dirname(pkgJsonPath), binRelativePath);
+}
+
+//#endregion
+//#region src/cli/tailordb/erd/schema.ts
+/**
+* Convert TailorDB field config to tbls column definition.
+* @param fieldName - Field name
+* @param fieldConfig - TailorDB field configuration
+* @returns tbls column definition
+*/
+function toTblsColumn(fieldName, fieldConfig) {
+	const baseType = fieldConfig.type || "string";
+	return {
+		name: fieldName,
+		type: fieldConfig.array ? `${baseType}[]` : baseType,
+		nullable: !fieldConfig.required,
+		comment: fieldConfig.description ?? ""
+	};
+}
+/**
+* Build tbls schema JSON from TailorDB types.
+* @param types - TailorDB types fetched from platform
+* @param namespace - TailorDB namespace
+* @returns tbls-compatible schema representation
+*/
+function buildTblsSchema(types, namespace) {
+	const tables = [];
+	const relations = [];
+	const referencedByTable = {};
+	const constraintsByTable = {};
+	const enumsMap = /* @__PURE__ */ new Map();
+	for (const type of types) {
+		const tableName = type.name;
+		const schema = type.schema;
+		const columns = [];
+		const tableConstraints = [];
+		columns.push({
+			name: "id",
+			type: "uuid",
+			nullable: false,
+			comment: ""
+		});
+		tableConstraints.push({
+			name: `pk_${tableName}`,
+			type: "PRIMARY KEY",
+			def: "",
+			table: tableName,
+			columns: ["id"]
+		});
+		if (schema) for (const [fieldName, fieldConfig] of Object.entries(schema.fields ?? {})) {
+			columns.push(toTblsColumn(fieldName, fieldConfig));
+			if (fieldConfig.type === "enum" && fieldConfig.allowedValues.length > 0) {
+				const enumName = `${tableName}_${fieldName}`;
+				let values = enumsMap.get(enumName);
+				if (!values) {
+					values = /* @__PURE__ */ new Set();
+					enumsMap.set(enumName, values);
+				}
+				for (const value of fieldConfig.allowedValues) values.add(value.value);
+			}
+			if (fieldConfig.foreignKey && fieldConfig.foreignKeyType) {
+				const foreignTable = fieldConfig.foreignKeyType;
+				const foreignColumn = fieldConfig.foreignKeyField || "id";
+				const childCardinality = fieldConfig.required ? "exactly_one" : "zero_or_one";
+				relations.push({
+					table: tableName,
+					columns: [fieldName],
+					parent_table: foreignTable,
+					parent_columns: [foreignColumn],
+					cardinality: childCardinality,
+					parent_cardinality: "zero_or_more",
+					def: ""
+				});
+				tableConstraints.push({
+					name: `fk_${tableName}_${fieldName}`,
+					type: "FOREIGN KEY",
+					def: "",
+					table: tableName,
+					columns: [fieldName],
+					referenced_table: foreignTable,
+					referenced_columns: [foreignColumn]
+				});
+				if (!referencedByTable[tableName]) referencedByTable[tableName] = /* @__PURE__ */ new Set();
+				referencedByTable[tableName].add(foreignTable);
+			}
+		}
+		constraintsByTable[tableName] = tableConstraints;
+		tables.push({
+			name: tableName,
+			type: "table",
+			comment: schema?.description ?? "",
+			columns,
+			indexes: [],
+			constraints: constraintsByTable[tableName] ?? [],
+			triggers: [],
+			def: "",
+			referenced_tables: []
+		});
+	}
+	for (const table of tables) {
+		const referenced = referencedByTable[table.name];
+		table.referenced_tables = referenced ? Array.from(referenced) : [];
+	}
+	const enums = [];
+	for (const [name, values] of enumsMap.entries()) enums.push({
+		name,
+		values: Array.from(values)
 	});
-	logger.success(`Truncated type "${options.typeName}" in namespace "${options.namespaceName}"`);
+	return {
+		name: namespace,
+		tables,
+		relations,
+		enums
+	};
 }
-async function truncateNamespace(workspaceId, namespaceName, client) {
-	await client.truncateTailorDBTypes({
-		workspaceId,
-		namespaceName
+/**
+* Export apply-applied TailorDB schema for a namespace as tbls-compatible JSON.
+* @param options - Export options
+* @returns tbls schema representation
+*/
+async function exportTailorDBSchema(options) {
+	const { client, workspaceId, namespace } = options;
+	const types = await fetchAll(async (pageToken) => {
+		try {
+			const { tailordbTypes, nextPageToken } = await client.listTailorDBTypes({
+				workspaceId,
+				namespaceName: namespace,
+				pageToken
+			});
+			return [tailordbTypes, nextPageToken];
+		} catch (error) {
+			if (error instanceof ConnectError && error.code === Code.NotFound) return [[], ""];
+			throw error;
+		}
 	});
-	logger.success(`Truncated all types in namespace "${namespaceName}"`);
+	if (types.length === 0) logger.warn(`No TailorDB types found in namespace "${namespace}". Returning empty schema.`);
+	return buildTblsSchema(types, namespace);
 }
-async function getAllNamespaces(configPath) {
-	const { config } = await loadConfig(configPath);
-	const namespaces = /* @__PURE__ */ new Set();
-	if (config.db) for (const [namespaceName] of Object.entries(config.db)) namespaces.add(namespaceName);
-	return Array.from(namespaces);
+/**
+* Writes the TailorDB schema to a file in tbls-compatible JSON format.
+* @param options - The options for writing the schema file.
+*/
+async function writeTblsSchemaToFile(options) {
+	const schema = await exportTailorDBSchema(options);
+	const json = JSON.stringify(schema, null, 2);
+	fs$1.mkdirSync(path.dirname(options.outputPath), { recursive: true });
+	fs$1.writeFileSync(options.outputPath, json, "utf8");
+	const relativePath = path.relative(process.cwd(), options.outputPath);
+	logger.success(`Wrote ERD schema to ${relativePath}`);
 }
-async function getTypeNamespace(workspaceId, typeName, client, configPath) {
-	const namespaces = await getAllNamespaces(configPath);
-	for (const namespace of namespaces) try {
-		const { tailordbTypes } = await client.listTailorDBTypes({
-			workspaceId,
-			namespaceName: namespace
-		});
-		if (tailordbTypes.some((type) => type.name === typeName)) return namespace;
-	} catch {
-		continue;
-	}
-	return null;
+
+//#endregion
+//#region src/cli/utils/beta.ts
+/**
+* Warn that the ERD CLI is a beta feature.
+*/
+function logErdBetaWarning() {
+	logger.warn("The ERD command is a beta feature and may introduce breaking changes in future releases.");
+	logger.newline();
 }
+
+//#endregion
+//#region src/cli/tailordb/erd/utils.ts
 /**
-* Truncate TailorDB data based on the given options.
-* @param {TruncateOptions} [options] - Truncate options (all, namespace, or types)
-* @returns {Promise<void>} Promise that resolves when truncation completes
+* Initialize shared ERD command context.
+* @param args - CLI arguments.
+* @returns Initialized context.
 */
-async function truncate(options) {
+async function initErdContext(args) {
+	logErdBetaWarning();
 	const client = await initOperatorClient(await loadAccessToken({
 		useProfile: true,
-		profile: options?.profile
+		profile: args.profile
 	}));
 	const workspaceId = loadWorkspaceId({
-		workspaceId: options?.workspaceId,
-		profile: options?.profile
+		workspaceId: args.workspaceId,
+		profile: args.profile
+	});
+	const { config } = await loadConfig(args.config);
+	return {
+		client,
+		workspaceId,
+		config
+	};
+}
+
+//#endregion
+//#region src/cli/tailordb/erd/export.ts
+const DEFAULT_ERD_BASE_DIR = ".tailor-sdk/erd";
+/**
+* Resolve TailorDB config and namespace.
+* @param config - Loaded Tailor SDK config.
+* @param explicitNamespace - Namespace override.
+* @returns Resolved namespace and erdSite.
+*/
+function resolveDbConfig(config, explicitNamespace) {
+	const namespace = explicitNamespace ?? Object.keys(config.db ?? {})[0];
+	if (!namespace) throw new Error("No TailorDB namespaces found in config. Please define db services in tailor.config.ts or pass --namespace.");
+	const dbConfig = config.db?.[namespace];
+	if (!dbConfig || typeof dbConfig !== "object" || "external" in dbConfig) throw new Error(`TailorDB namespace "${namespace}" not found in config.db.`);
+	return {
+		namespace,
+		erdSite: dbConfig.erdSite
+	};
+}
+/**
+* Get all namespaces with erdSite configured.
+* @param config - Loaded Tailor SDK config.
+* @returns Namespaces with erdSite.
+*/
+function resolveAllErdSites(config) {
+	const results = [];
+	for (const [namespace, dbConfig] of Object.entries(config.db ?? {})) if (dbConfig && typeof dbConfig === "object" && !("external" in dbConfig) && dbConfig.erdSite) results.push({
+		namespace,
+		erdSite: dbConfig.erdSite
 	});
-	const hasTypes = options?.types && options.types.length > 0;
-	const hasNamespace = !!options?.namespace;
-	const hasAll = !!options?.all;
-	const optionCount = [
-		hasAll,
-		hasNamespace,
-		hasTypes
-	].filter(Boolean).length;
-	if (optionCount === 0) throw new Error("Please specify one of: --all, --namespace <name>, or type names");
-	if (optionCount > 1) throw new Error("Options --all, --namespace, and type names are mutually exclusive. Please specify only one.");
-	const namespaces = await getAllNamespaces(options?.configPath);
-	if (hasAll) {
-		if (namespaces.length === 0) {
-			logger.warn("No namespaces found in config file.");
+	return results;
+}
+/**
+* Run the liam CLI to build an ERD static site from a schema file.
+* @param schemaPath - Path to the ERD schema JSON file
+* @param cwd - Working directory where liam will run (dist is created here)
+* @returns Resolves when the build completes successfully
+*/
+async function runLiamBuild(schemaPath, cwd) {
+	fs$1.mkdirSync(cwd, { recursive: true });
+	return await new Promise((resolve, reject) => {
+		let liamBinPath;
+		try {
+			liamBinPath = resolveCliBinPath({
+				cwd,
+				packageName: "@liam-hq/cli",
+				binName: "liam",
+				installHint: "npm i -D @liam-hq/cli"
+			});
+		} catch (error) {
+			logger.error(String(error));
+			reject(error);
 			return;
 		}
-		if (!options?.yes) {
-			const namespaceList = namespaces.join(", ");
-			if (!await logger.prompt(`This will truncate ALL tables in the following namespaces: ${namespaceList}. Continue? (yes/no)`, {
-				type: "confirm",
-				initial: false
-			})) {
-				logger.info("Truncate cancelled.");
-				return;
+		const child = spawn(process.execPath, [
+			liamBinPath,
+			"erd",
+			"build",
+			"--format",
+			"tbls",
+			"--input",
+			schemaPath
+		], {
+			stdio: "inherit",
+			cwd
+		});
+		child.on("error", (error) => {
+			logger.error("Failed to run `@liam-hq/cli`. Ensure it is installed in your project.");
+			reject(error);
+		});
+		child.on("exit", (code) => {
+			if (code === 0) resolve();
+			else {
+				logger.error("liam CLI exited with a non-zero code. Ensure `@liam-hq/cli erd build --format tbls --input schema.json` works in your project.");
+				reject(/* @__PURE__ */ new Error(`liam CLI exited with code ${code ?? 1}`));
 			}
-		}
-		for (const namespace of namespaces) await truncateNamespace(workspaceId, namespace, client);
-		logger.success("Truncated all tables in all namespaces");
-		return;
+		});
+	});
+}
+/**
+* Export TailorDB schema and build ERD artifacts via liam.
+* @param options - Build options.
+*/
+async function prepareErdBuild(options) {
+	await writeTblsSchemaToFile(options);
+	await runLiamBuild(options.outputPath, options.erdDir);
+}
+/**
+* Prepare ERD builds for one or more namespaces.
+* @param options - Build options.
+* @returns Build results by namespace.
+*/
+async function prepareErdBuilds(options) {
+	const { client, workspaceId, config } = options;
+	const baseDir = options.outputDir ?? path.resolve(process.cwd(), DEFAULT_ERD_BASE_DIR);
+	let targets;
+	if (options.namespace) {
+		const { namespace, erdSite } = resolveDbConfig(config, options.namespace);
+		const erdDir = path.join(baseDir, namespace);
+		targets = [{
+			namespace,
+			erdSite,
+			schemaOutputPath: path.join(erdDir, "schema.json"),
+			distDir: path.join(erdDir, "dist"),
+			erdDir
+		}];
+	} else {
+		const erdSites = resolveAllErdSites(config);
+		if (erdSites.length === 0) throw new Error("No namespaces with erdSite configured found. Add erdSite: \"<static-website-name>\" to db.<namespace> in tailor.config.ts.");
+		logger.info(`Found ${erdSites.length} namespace(s) with erdSite configured.`);
+		targets = erdSites.map(({ namespace, erdSite }) => {
+			const erdDir = path.join(baseDir, namespace);
+			return {
+				namespace,
+				erdSite,
+				schemaOutputPath: path.join(erdDir, "schema.json"),
+				distDir: path.join(erdDir, "dist"),
+				erdDir
+			};
+		});
 	}
-	if (hasNamespace && options?.namespace) {
-		const namespace = options.namespace;
-		if (!namespaces.includes(namespace)) throw new Error(`Namespace "${namespace}" not found in config. Available namespaces: ${namespaces.join(", ")}`);
-		if (!options.yes) {
-			if (!await logger.prompt(`This will truncate ALL tables in namespace "${namespace}". Continue? (yes/no)`, {
-				type: "confirm",
-				initial: false
-			})) {
-				logger.info("Truncate cancelled.");
-				return;
-			}
+	await Promise.all(targets.map((target) => prepareErdBuild({
+		namespace: target.namespace,
+		client,
+		workspaceId,
+		outputPath: target.schemaOutputPath,
+		erdDir: target.erdDir
+	})));
+	return targets;
+}
+const erdExportCommand = defineCommand({
+	meta: {
+		name: "export",
+		description: "Export Liam ERD dist from applied TailorDB schema (beta)"
+	},
+	args: {
+		...commonArgs,
+		...deploymentArgs,
+		...jsonArgs,
+		namespace: {
+			type: "string",
+			description: "TailorDB namespace name (optional if only one namespace is defined in config)",
+			alias: "n"
+		},
+		output: {
+			type: "string",
+			description: "Output directory path for tbls-compatible ERD JSON (writes to <outputDir>/<namespace>/schema.json)",
+			alias: "o",
+			default: DEFAULT_ERD_BASE_DIR
 		}
-		await truncateNamespace(workspaceId, namespace, client);
-		return;
-	}
-	if (hasTypes && options?.types) {
-		const typeNames = options.types;
-		const typeNamespaceMap = /* @__PURE__ */ new Map();
-		const notFoundTypes = [];
-		for (const typeName of typeNames) {
-			const namespace = await getTypeNamespace(workspaceId, typeName, client, options.configPath);
-			if (namespace) typeNamespaceMap.set(typeName, namespace);
-			else notFoundTypes.push(typeName);
+	},
+	run: withCommonArgs(async (args) => {
+		const { client, workspaceId, config } = await initErdContext(args);
+		const outputDir = path.resolve(process.cwd(), String(args.output));
+		const results = await prepareErdBuilds({
+			client,
+			workspaceId,
+			config,
+			namespace: args.namespace,
+			outputDir
+		});
+		if (args.json) logger.out(results.map((result) => ({
+			namespace: result.namespace,
+			distDir: result.distDir,
+			schemaOutputPath: result.schemaOutputPath
+		})));
+		else for (const result of results) {
+			logger.out(`Exported ERD for namespace "${result.namespace}"`);
+			logger.out(`  - Liam ERD dist: ${result.distDir}`);
+			logger.out(`  - tbls schema.json: ${result.schemaOutputPath}`);
 		}
-		if (notFoundTypes.length > 0) throw new Error(`The following types were not found in any namespace: ${notFoundTypes.join(", ")}`);
-		if (!options.yes) {
-			const typeList = typeNames.join(", ");
-			if (!await logger.prompt(`This will truncate the following types: ${typeList}. Continue? (yes/no)`, {
-				type: "confirm",
-				initial: false
-			})) {
-				logger.info("Truncate cancelled.");
-				return;
-			}
+	})
+});
+
+//#endregion
+//#region src/cli/tailordb/erd/deploy.ts
+const erdDeployCommand = defineCommand({
+	meta: {
+		name: "deploy",
+		description: "Deploy ERD static website for TailorDB namespace(s) (beta)"
+	},
+	args: {
+		...commonArgs,
+		...deploymentArgs,
+		...jsonArgs,
+		namespace: {
+			type: "string",
+			description: "TailorDB namespace name (optional - deploys all namespaces with erdSite if omitted)",
+			alias: "n"
 		}
-		for (const typeName of typeNames) {
-			const namespace = typeNamespaceMap.get(typeName);
-			if (!namespace) continue;
-			await truncateSingleType({
-				workspaceId,
-				namespaceName: namespace,
-				typeName
-			}, client);
+	},
+	run: withCommonArgs(async (args) => {
+		const { client, workspaceId, config } = await initErdContext(args);
+		const buildResults = await prepareErdBuilds({
+			client,
+			workspaceId,
+			config,
+			namespace: args.namespace
+		});
+		const deployResults = await Promise.all(buildResults.map(async (result) => {
+			if (!result.erdSite) throw new Error(`No erdSite configured for namespace "${result.namespace}". Add erdSite: "<static-website-name>" to db.${result.namespace} in tailor.config.ts.`);
+			if (!args.json) logger.info(`Deploying ERD for namespace "${result.namespace}" to site "${result.erdSite}"...`);
+			const { url, skippedFiles } = await deployStaticWebsite(client, workspaceId, result.erdSite, result.distDir, !args.json);
+			return {
+				namespace: result.namespace,
+				erdSite: result.erdSite,
+				url,
+				skippedFiles
+			};
+		}));
+		if (args.json) logger.out(deployResults);
+		else for (const result of deployResults) {
+			logger.success(`ERD site "${result.erdSite}" deployed successfully.`);
+			logger.out(result.url);
+			logSkippedFiles(result.skippedFiles);
 		}
+	})
+});
+
+//#endregion
+//#region src/cli/tailordb/erd/serve.ts
+function formatServeCommand(namespace) {
+	return `tailor-sdk tailordb erd serve --namespace ${namespace}`;
+}
+async function runServeDist(results) {
+	if (results.length === 0) throw new Error("No ERD build results found.");
+	const [primary, ...rest] = results;
+	logger.info(`Serving ERD for namespace "${primary.namespace}".`);
+	if (rest.length > 0) {
+		const commands = rest.map((result) => `  - ${formatServeCommand(result.namespace)}`).join("\n");
+		logger.warn(`Multiple namespaces found. To serve another namespace, run:\n${commands}`);
 	}
+	fs$1.mkdirSync(primary.erdDir, { recursive: true });
+	return await new Promise((resolve, reject) => {
+		let serveBinPath;
+		try {
+			serveBinPath = resolveCliBinPath({
+				cwd: primary.erdDir,
+				packageName: "serve",
+				binName: "serve",
+				installHint: "npm i -D serve"
+			});
+		} catch (error) {
+			logger.error(String(error));
+			reject(error);
+			return;
+		}
+		const child = spawn(process.execPath, [serveBinPath, "dist"], {
+			stdio: "inherit",
+			cwd: primary.erdDir
+		});
+		child.on("error", (error) => {
+			logger.error("Failed to run `serve dist`. Ensure `serve` is installed in your project.");
+			reject(error);
+		});
+		child.on("exit", (code) => {
+			if (code === 0) resolve();
+			else {
+				logger.error("serve CLI exited with a non-zero code. Ensure `serve dist` works in your project.");
+				reject(/* @__PURE__ */ new Error(`serve CLI exited with code ${code ?? 1}`));
+			}
+		});
+	});
 }
-const truncateCommand = defineCommand({
+const erdServeCommand = defineCommand({
 	meta: {
-		name: "truncate",
-		description: "Truncate TailorDB tables"
+		name: "serve",
+		description: "Generate and serve ERD (liam build + `serve dist`) (beta)"
 	},
 	args: {
 		...commonArgs,
-		types: {
-			type: "positional",
-			description: "Type names to truncate",
-			required: false
-		},
-		all: {
-			type: "boolean",
-			description: "Truncate all tables in all namespaces",
-			default: false,
-			alias: "a"
-		},
+		...deploymentArgs,
 		namespace: {
 			type: "string",
-			description: "Truncate all tables in specified namespace",
+			description: "TailorDB namespace name (uses first namespace in config if not specified)",
 			alias: "n"
-		},
-		yes: {
-			type: "boolean",
-			description: "Skip confirmation prompt",
-			alias: "y",
-			default: false
-		},
-		...deploymentArgs
+		}
 	},
 	run: withCommonArgs(async (args) => {
-		const types = args._.length > 0 ? args._.map((arg) => String(arg)).filter(Boolean) : void 0;
-		await truncate({
-			workspaceId: args["workspace-id"],
-			profile: args.profile,
-			configPath: args.config,
-			all: args.all,
-			namespace: args.namespace,
-			types,
-			yes: args.yes
-		});
+		const { client, workspaceId, config } = await initErdContext(args);
+		await runServeDist(await prepareErdBuilds({
+			client,
+			workspaceId,
+			config,
+			namespace: args.namespace
+		}));
 	})
 });
 
+//#endregion
+//#region src/cli/tailordb/erd/index.ts
+const erdCommand = defineCommand({
+	meta: {
+		name: "erd",
+		description: "ERD utilities for TailorDB (beta)"
+	},
+	subCommands: {
+		export: erdExportCommand,
+		serve: erdServeCommand,
+		deploy: erdDeployCommand
+	}
+});
+
 //#endregion
 //#region src/cli/tailordb/index.ts
 const tailordbCommand = defineCommand({
@@ -1262,7 +1619,10 @@ const tailordbCommand = defineCommand({
 		name: "tailordb",
 		description: "Manage TailorDB tables and data"
 	},
-	subCommands: { truncate: truncateCommand }
+	subCommands: {
+		erd: erdCommand,
+		truncate: truncateCommand
+	}
 });
 
 //#endregion
@@ -1330,8 +1690,8 @@ function patScopeToString(scope) {
 }
 /**
 * Transform a PersonalAccessToken into CLI-friendly info.
-* @param {PersonalAccessToken} pat - Personal access token resource
-* @returns {PersonalAccessTokenInfo} Flattened token info
+* @param pat - Personal access token resource
+* @returns Flattened token info
 */
 function transformPersonalAccessToken(pat) {
 	return {
@@ -1341,8 +1701,8 @@ function transformPersonalAccessToken(pat) {
 }
 /**
 * Get PAT scopes from a write flag.
-* @param {boolean} write - Whether write access is required
-* @returns {PATScope[]} Scopes to apply to the token
+* @param write - Whether write access is required
+* @returns Scopes to apply to the token
 */
 function getScopesFromWriteFlag(write) {
 	return write ? [PATScope.PAT_SCOPE_READ, PATScope.PAT_SCOPE_WRITE] : [PATScope.PAT_SCOPE_READ];
@@ -1352,11 +1712,10 @@ function getScopeStringsFromWriteFlag(write) {
 }
 /**
 * Print the created or updated personal access token to the logger.
-* @param {string} name - Token name
-* @param {string} token - Token value
-* @param {boolean} write - Whether the token has write scope
-* @param {"created" | "updated"} action - Action performed
-* @returns {void}
+* @param name - Token name
+* @param token - Token value
+* @param write - Whether the token has write scope
+* @param action - Action performed
 */
 function printCreatedToken(name, token, write, action) {
 	const scopes = getScopeStringsFromWriteFlag(write);