@zenstackhq/cli 3.5.5 → 3.6.0

package/dist/index.mjs

@@ -0,0 +1,3446 @@
+import { createRequire } from "node:module";
+import { ZModelCodeGenerator, ZModelLanguageMetaData, formatDocument, loadDocument } from "@zenstackhq/language";
+import colors from "colors";
+import { Command, CommanderError, Option } from "commander";
+import "dotenv/config";
+import { DataModel, Enum, isDataSource, isEnum, isInvocationExpr, isLiteralExpr, isPlugin } from "@zenstackhq/language/ast";
+import path from "node:path";
+import { invariant, lowerCaseFirst, singleDebounce } from "@zenstackhq/common-helpers";
+import { PrismaSchemaGenerator, TsSchemaGenerator } from "@zenstackhq/sdk";
+import { createJiti } from "jiti";
+import fs from "node:fs";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import terminalLink from "terminal-link";
+import { z } from "zod";
+import ora from "ora";
+import { execSync } from "child_process";
+import { fileURLToPath as fileURLToPath$1 } from "url";
+import { DataFieldAttributeFactory, DataFieldFactory, DataModelFactory, EnumFactory } from "@zenstackhq/language/factory";
+import { AstUtils } from "langium";
+import { getLiteral, getLiteralArray, getStringLiteral } from "@zenstackhq/language/utils";
+import { watch } from "chokidar";
+import semver from "semver";
+import { detect, resolveCommand } from "package-manager-detector";
+import { execaCommand } from "execa";
+import { ZenStackClient } from "@zenstackhq/orm";
+import { MysqlDialect } from "@zenstackhq/orm/dialects/mysql";
+import { PostgresDialect } from "@zenstackhq/orm/dialects/postgres";
+import { SqliteDialect } from "@zenstackhq/orm/dialects/sqlite";
+import { RPCApiHandler } from "@zenstackhq/server/api";
+import { ZenStackMiddleware } from "@zenstackhq/server/express";
+import cors from "cors";
+import express from "express";
+import { init } from "mixpanel";
+import { createHash, randomUUID } from "node:crypto";
+import * as os$1 from "os";
+import process$1, { env } from "node:process";
+import os from "node:os";
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+//#endregion
+//#region src/cli-error.ts
+/**
+* Indicating an error during CLI execution
+*/
+var CliError = class extends Error {};
+//#endregion
+//#region src/actions/action-utils.ts
+function getSchemaFile(file) {
+	if (file) {
+		if (!fs.existsSync(file)) throw new CliError(`Schema file not found: ${file}`);
+		return file;
+	}
+	const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+	if (pkgJsonConfig.schema) {
+		if (!fs.existsSync(pkgJsonConfig.schema)) throw new CliError(`Schema file not found: ${pkgJsonConfig.schema}`);
+		if (fs.statSync(pkgJsonConfig.schema).isDirectory()) {
+			const schemaPath = path.join(pkgJsonConfig.schema, "schema.zmodel");
+			if (!fs.existsSync(schemaPath)) throw new CliError(`Schema file not found: ${schemaPath}`);
+			return schemaPath;
+		} else return pkgJsonConfig.schema;
+	}
+	if (fs.existsSync("./schema.zmodel")) return "./schema.zmodel";
+	else if (fs.existsSync("./zenstack/schema.zmodel")) return "./zenstack/schema.zmodel";
+	else throw new CliError("Schema file not found in default locations (\"./schema.zmodel\" or \"./zenstack/schema.zmodel\").");
+}
+async function loadSchemaDocument(schemaFile, opts = {}) {
+	const returnServices = opts.returnServices ?? false;
+	const loadResult = await loadDocument(schemaFile, [], opts.mergeImports ?? true);
+	if (!loadResult.success) {
+		loadResult.errors.forEach((err) => {
+			console.error(colors.red(err));
+		});
+		throw new CliError("Schema contains errors. See above for details.");
+	}
+	loadResult.warnings.forEach((warn) => {
+		console.warn(colors.yellow(warn));
+	});
+	if (returnServices) return {
+		model: loadResult.model,
+		services: loadResult.services
+	};
+	return loadResult.model;
+}
+function handleSubProcessError$1(err) {
+	if (err instanceof Error && "status" in err && typeof err.status === "number") process.exit(err.status);
+	else process.exit(1);
+}
+async function generateTempPrismaSchema(zmodelPath, folder) {
+	const model = await loadSchemaDocument(zmodelPath);
+	if (!model.declarations.some(isDataSource)) throw new CliError("Schema must define a datasource");
+	const prismaSchema = await new PrismaSchemaGenerator(model).generate();
+	if (!folder) folder = path.dirname(zmodelPath);
+	const prismaSchemaFile = path.resolve(folder, "~schema.prisma");
+	fs.writeFileSync(prismaSchemaFile, prismaSchema);
+	return prismaSchemaFile;
+}
+function getPkgJsonConfig(startPath) {
+	const result = {
+		schema: void 0,
+		output: void 0,
+		seed: void 0
+	};
+	const pkgJsonFile = findUp(["package.json"], startPath, false);
+	if (!pkgJsonFile) return result;
+	let pkgJson = void 0;
+	try {
+		pkgJson = JSON.parse(fs.readFileSync(pkgJsonFile, "utf8"));
+	} catch {
+		return result;
+	}
+	if (pkgJson.zenstack && typeof pkgJson.zenstack === "object") {
+		result.schema = pkgJson.zenstack.schema && typeof pkgJson.zenstack.schema === "string" ? path.resolve(path.dirname(pkgJsonFile), pkgJson.zenstack.schema) : void 0;
+		result.output = pkgJson.zenstack.output && typeof pkgJson.zenstack.output === "string" ? path.resolve(path.dirname(pkgJsonFile), pkgJson.zenstack.output) : void 0;
+		result.seed = typeof pkgJson.zenstack.seed === "string" && pkgJson.zenstack.seed ? pkgJson.zenstack.seed : void 0;
+	}
+	return result;
+}
+function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
+	if (!names.some((name) => !!name)) return;
+	const target = names.find((name) => fs.existsSync(path.join(cwd, name)));
+	if (multiple === false && target) return path.resolve(cwd, target);
+	if (target) result.push(path.resolve(cwd, target));
+	const up = path.resolve(cwd, "..");
+	if (up === cwd) return multiple && result.length > 0 ? result : void 0;
+	return findUp(names, up, multiple, result);
+}
+async function requireDataSourceUrl(schemaFile) {
+	if (!(await loadSchemaDocument(schemaFile)).declarations.find(isDataSource)?.fields.some((f) => f.name === "url")) throw new CliError("The schema's \"datasource\" must have a \"url\" field to use this command.");
+}
+function getOutputPath(options, schemaFile) {
+	if (options.output) return options.output;
+	const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+	if (pkgJsonConfig.output) return pkgJsonConfig.output;
+	else return path.dirname(schemaFile);
+}
+async function getZenStackPackages(searchPath) {
+	const pkgJsonFile = findUp(["package.json"], searchPath, false);
+	if (!pkgJsonFile) return [];
+	let pkgJson;
+	try {
+		pkgJson = JSON.parse(fs.readFileSync(pkgJsonFile, "utf8"));
+	} catch {
+		return [];
+	}
+	const packages = Array.from(new Set([...Object.keys(pkgJson.dependencies ?? {}), ...Object.keys(pkgJson.devDependencies ?? {})].filter((p) => p.startsWith("@zenstackhq/")))).sort();
+	const require = createRequire(pkgJsonFile);
+	return packages.map((pkg) => {
+		try {
+			const depPkgJson = require(`${pkg}/package.json`);
+			if (depPkgJson.private) return;
+			return {
+				pkg,
+				version: depPkgJson.version
+			};
+		} catch {
+			return {
+				pkg,
+				version: void 0
+			};
+		}
+	}).filter((p) => !!p);
+}
+function getPluginProvider(plugin) {
+	const providerField = plugin.fields.find((f) => f.name === "provider");
+	invariant(providerField, `Plugin ${plugin.name} does not have a provider field`);
+	return providerField.value.value;
+}
+async function loadPluginModule(provider, basePath) {
+	if (provider.toLowerCase().endsWith(".zmodel")) return;
+	let moduleSpec = provider;
+	if (moduleSpec.startsWith(".")) moduleSpec = path.resolve(basePath, moduleSpec);
+	const importAsEsm = async (spec) => {
+		try {
+			const result = (await import(spec)).default;
+			return typeof result?.generate === "function" ? result : void 0;
+		} catch (err) {
+			throw new CliError(`Failed to load plugin module from ${spec}: ${err.message}`);
+		}
+	};
+	const jiti = createJiti(pathToFileURL(basePath).toString());
+	const importAsTs = async (spec) => {
+		try {
+			const result = await jiti.import(spec, { default: true });
+			return typeof result?.generate === "function" ? result : void 0;
+		} catch (err) {
+			throw new CliError(`Failed to load plugin module from ${spec}: ${err.message}`);
+		}
+	};
+	const esmSuffixes = [".js", ".mjs"];
+	const tsSuffixes = [".ts", ".mts"];
+	if (fs.existsSync(moduleSpec) && fs.statSync(moduleSpec).isFile()) {
+		if (esmSuffixes.some((suffix) => moduleSpec.endsWith(suffix))) return await importAsEsm(pathToFileURL(moduleSpec).toString());
+		if (tsSuffixes.some((suffix) => moduleSpec.endsWith(suffix))) return await importAsTs(moduleSpec);
+	}
+	for (const suffix of esmSuffixes) {
+		const indexPath = path.join(moduleSpec, `index${suffix}`);
+		if (fs.existsSync(indexPath)) return await importAsEsm(pathToFileURL(indexPath).toString());
+	}
+	for (const suffix of tsSuffixes) {
+		const indexPath = path.join(moduleSpec, `index${suffix}`);
+		if (fs.existsSync(indexPath)) return await importAsTs(indexPath);
+	}
+	try {
+		const result = await jiti.import(moduleSpec, { default: true });
+		return typeof result.generate === "function" ? result : void 0;
+	} catch {}
+	try {
+		const mod = await import(moduleSpec);
+		return typeof mod.default?.generate === "function" ? mod.default : void 0;
+	} catch (err) {
+		const errorCode = err?.code;
+		if (errorCode === "ERR_MODULE_NOT_FOUND" || errorCode === "MODULE_NOT_FOUND") throw new CliError(`Cannot find plugin module "${provider}". Please make sure the package exists.`);
+		throw new CliError(`Failed to load plugin module "${provider}": ${err.message}`);
+	}
+}
+const FETCH_CLI_MAX_TIME = 1e3;
+const CLI_CONFIG_ENDPOINT = "https://zenstack.dev/config/cli-v3.json";
+const usageTipsSchema = z.object({ notifications: z.array(z.object({
+	title: z.string(),
+	url: z.url().optional(),
+	active: z.boolean()
+})) });
+/**
+* Starts the usage tips fetch in the background. Returns a callback that, when invoked check if the fetch
+* is complete. If not complete, it will wait until the max time is reached. After that, if fetch is still
+* not complete, just return.
+*/
+function startUsageTipsFetch() {
+	let fetchedData = void 0;
+	let fetchComplete = false;
+	const start = Date.now();
+	const controller = new AbortController();
+	fetch(CLI_CONFIG_ENDPOINT, {
+		headers: { accept: "application/json" },
+		signal: controller.signal
+	}).then(async (res) => {
+		if (!res.ok) return;
+		const data = await res.json();
+		const parseResult = usageTipsSchema.safeParse(data);
+		if (parseResult.success) fetchedData = parseResult.data;
+	}).catch(() => {}).finally(() => {
+		fetchComplete = true;
+	});
+	return async () => {
+		const elapsed = Date.now() - start;
+		if (!fetchComplete && elapsed < FETCH_CLI_MAX_TIME) await new Promise((resolve) => setTimeout(resolve, FETCH_CLI_MAX_TIME - elapsed));
+		if (!fetchComplete) {
+			controller.abort();
+			return;
+		}
+		if (!fetchedData) return;
+		const activeItems = fetchedData.notifications.filter((item) => item.active);
+		if (activeItems.length > 0) {
+			const item = activeItems[Math.floor(Math.random() * activeItems.length)];
+			if (item.url) console.log(terminalLink(item.title, item.url));
+			else console.log(item.title);
+		}
+	};
+}
+//#endregion
+//#region src/actions/check.ts
+/**
+* CLI action for checking a schema's validity.
+*/
+async function run$8(options) {
+	const schemaFile = getSchemaFile(options.schema);
+	try {
+		await checkPluginResolution(schemaFile, await loadSchemaDocument(schemaFile));
+		console.log(colors.green("✓ Schema validation completed successfully."));
+	} catch (error) {
+		console.error(colors.red("✗ Schema validation failed."));
+		throw error;
+	}
+}
+async function checkPluginResolution(schemaFile, model) {
+	const plugins = model.declarations.filter(isPlugin);
+	for (const plugin of plugins) {
+		const provider = getPluginProvider(plugin);
+		if (!provider.startsWith("@core/")) {
+			const pluginSourcePath = plugin.$cstNode?.parent?.element.$document?.uri?.fsPath ?? schemaFile;
+			await loadPluginModule(provider, path.dirname(pluginSourcePath));
+		}
+	}
+}
+//#endregion
+//#region src/utils/exec-utils.ts
+/**
+* Utility for executing command synchronously and prints outputs on current console
+*/
+function execSync$1(cmd, options) {
+	const { env, ...restOptions } = options ?? {};
+	const mergedEnv = env ? {
+		...process.env,
+		...env
+	} : void 0;
+	execSync(cmd, {
+		encoding: "utf-8",
+		stdio: options?.stdio ?? "inherit",
+		env: mergedEnv,
+		...restOptions
+	});
+}
+/**
+* Utility for running package commands through npx/bunx
+*/
+function execPackage(cmd, options) {
+	execSync$1(`${process?.versions?.["bun"] ? "bunx" : "npx"} ${cmd}`, options);
+}
+/**
+* Utility for running prisma commands
+*/
+function execPrisma(args, options) {
+	let prismaPath;
+	try {
+		if (typeof import.meta.resolve === "function") prismaPath = fileURLToPath$1(import.meta.resolve("prisma/build/index.js"));
+		else prismaPath = __require.resolve("prisma/build/index.js");
+	} catch {}
+	const _options = {
+		...options,
+		env: {
+			...options?.env,
+			PRISMA_HIDE_UPDATE_MESSAGE: "1"
+		}
+	};
+	if (!prismaPath) {
+		execPackage(`prisma ${args}`, _options);
+		return;
+	}
+	execSync$1(`node "${prismaPath}" ${args}`, _options);
+}
+//#endregion
+//#region src/actions/pull/utils.ts
+function isDatabaseManagedAttribute(name) {
+	return [
+		"@relation",
+		"@id",
+		"@unique"
+	].includes(name) || name.startsWith("@db.");
+}
+function getDatasource(model) {
+	const datasource = model.declarations.find((d) => d.$type === "DataSource");
+	if (!datasource) throw new CliError("No datasource declaration found in the schema.");
+	const urlField = datasource.fields.find((f) => f.name === "url");
+	if (!urlField) throw new CliError(`No url field found in the datasource declaration.`);
+	let url = getStringLiteral(urlField.value);
+	if (!url && isInvocationExpr(urlField.value)) {
+		const envName = getStringLiteral(urlField.value.args[0]?.value);
+		if (!envName) throw new CliError("The url field must be a string literal or an env().");
+		if (!process.env[envName]) throw new CliError(`Environment variable ${envName} is not set, please set it to the database connection string.`);
+		url = process.env[envName];
+	}
+	if (!url) throw new CliError("The url field must be a string literal or an env().");
+	if (url.startsWith("file:")) {
+		url = new URL(url, `file:${model.$document.uri.path}`).pathname;
+		if (process.platform === "win32" && url[0] === "/") url = url.slice(1);
+	}
+	const defaultSchemaField = datasource.fields.find((f) => f.name === "defaultSchema");
+	const defaultSchema = defaultSchemaField && getStringLiteral(defaultSchemaField.value) || "public";
+	const schemasField = datasource.fields.find((f) => f.name === "schemas");
+	const schemas = schemasField && getLiteralArray(schemasField.value)?.filter((s) => s !== void 0) || [];
+	const provider = getStringLiteral(datasource.fields.find((f) => f.name === "provider")?.value);
+	if (!provider) throw new CliError(`Datasource "${datasource.name}" is missing a "provider" field.`);
+	return {
+		name: datasource.name,
+		provider,
+		url,
+		defaultSchema,
+		schemas,
+		allSchemas: [defaultSchema, ...schemas]
+	};
+}
+function getDbName(decl, includeSchema = false) {
+	if (!("attributes" in decl)) return decl.name;
+	const schemaAttr = decl.attributes.find((a) => a.decl.ref?.name === "@@schema");
+	let schema = "public";
+	if (schemaAttr) {
+		const schemaAttrValue = schemaAttr.args[0]?.value;
+		if (schemaAttrValue?.$type === "StringLiteral") schema = schemaAttrValue.value;
+	}
+	const formatName = (name) => `${schema && includeSchema ? `${schema}.` : ""}${name}`;
+	const nameAttr = decl.attributes.find((a) => a.decl.ref?.name === "@@map" || a.decl.ref?.name === "@map");
+	if (!nameAttr) return formatName(decl.name);
+	const attrValue = nameAttr.args[0]?.value;
+	if (attrValue?.$type !== "StringLiteral") return formatName(decl.name);
+	return formatName(attrValue.value);
+}
+function getRelationFkName(decl) {
+	return ((decl?.attributes.find((a) => a.decl.ref?.name === "@relation"))?.args.find((a) => a.name === "map")?.value)?.value;
+}
+/**
+* Gets the FK field names from the @relation attribute's `fields` argument.
+* Returns a sorted, comma-separated string of field names for comparison.
+* e.g., @relation(fields: [userId], references: [id]) -> "userId"
+* e.g., @relation(fields: [postId, tagId], references: [id, id]) -> "postId,tagId"
+*/
+function getRelationFieldsKey(decl) {
+	const relationAttr = decl?.attributes.find((a) => a.decl.ref?.name === "@relation");
+	if (!relationAttr) return void 0;
+	const fieldsArg = relationAttr.args.find((a) => a.name === "fields")?.value;
+	if (!fieldsArg || fieldsArg.$type !== "ArrayExpr") return void 0;
+	const fieldNames = fieldsArg.items.filter((item) => item.$type === "ReferenceExpr").map((item) => item.target?.$refText || item.target?.ref?.name).filter((name) => !!name).sort();
+	return fieldNames.length > 0 ? fieldNames.join(",") : void 0;
+}
+function getDeclarationRef(type, name, services) {
+	const node = services.shared.workspace.IndexManager.allElements(type).find((m) => m.node && getDbName(m.node) === name)?.node;
+	if (!node) throw new CliError(`Declaration not found: ${name}`);
+	return node;
+}
+function getEnumRef(name, services) {
+	return getDeclarationRef("Enum", name, services);
+}
+function getAttributeRef(name, services) {
+	return getDeclarationRef("Attribute", name, services);
+}
+function getFunctionRef(name, services) {
+	return getDeclarationRef("FunctionDecl", name, services);
+}
+/**
+* Normalize a default value string for a Float field.
+* - Integer strings get `.0` appended
+* - Decimal strings are preserved as-is
+*/
+function normalizeFloatDefault(val) {
+	if (/^-?\d+$/.test(val)) return (ab) => ab.NumberLiteral.setValue(val + ".0");
+	if (/^-?\d+\.\d+$/.test(val)) return (ab) => ab.NumberLiteral.setValue(val);
+	return (ab) => ab.NumberLiteral.setValue(val);
+}
+/**
+* Normalize a default value string for a Decimal field.
+* - Integer strings get `.00` appended
+* - Decimal strings are normalized to minimum 2 decimal places, stripping excess trailing zeros
+*/
+function normalizeDecimalDefault(val) {
+	if (/^-?\d+$/.test(val)) return (ab) => ab.NumberLiteral.setValue(val + ".00");
+	if (/^-?\d+\.\d+$/.test(val)) {
+		const [integerPart, fractionalPart] = val.split(".");
+		let normalized = fractionalPart.replace(/0+$/, "");
+		if (normalized.length < 2) normalized = normalized.padEnd(2, "0");
+		return (ab) => ab.NumberLiteral.setValue(`${integerPart}.${normalized}`);
+	}
+	return (ab) => ab.NumberLiteral.setValue(val);
+}
+//#endregion
+//#region src/actions/pull/casing.ts
+function resolveNameCasing(casing, originalName) {
+	let name = originalName;
+	const fieldPrefix = /[0-9]/g.test(name.charAt(0)) ? "_" : "";
+	switch (casing) {
+		case "pascal":
+			name = toPascalCase(originalName);
+			break;
+		case "camel":
+			name = toCamelCase(originalName);
+			break;
+		case "snake":
+			name = toSnakeCase(originalName);
+			break;
+	}
+	return {
+		modified: name !== originalName || fieldPrefix !== "",
+		name: `${fieldPrefix}${name}`
+	};
+}
+function isAllUpperCase(str) {
+	return str === str.toUpperCase();
+}
+function toPascalCase(str) {
+	if (isAllUpperCase(str)) return str;
+	return str.replace(/[_\- ]+(\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
+}
+function toCamelCase(str) {
+	if (isAllUpperCase(str)) return str;
+	return str.replace(/[_\- ]+(\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toLowerCase());
+}
+function toSnakeCase(str) {
+	if (isAllUpperCase(str)) return str;
+	return str.replace(/[- ]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+//#endregion
+//#region src/actions/pull/index.ts
+function syncEnums({ dbEnums, model, oldModel, provider, options, services, defaultSchema }) {
+	if (provider.isSupportedFeature("NativeEnum")) for (const dbEnum of dbEnums) {
+		const { modified, name } = resolveNameCasing(options.modelCasing, dbEnum.enum_type);
+		if (modified) console.log(colors.gray(`Mapping enum ${dbEnum.enum_type} to ${name}`));
+		const factory = new EnumFactory().setName(name);
+		if (modified || options.alwaysMap) factory.addAttribute((builder) => builder.setDecl(getAttributeRef("@@map", services)).addArg((argBuilder) => argBuilder.StringLiteral.setValue(dbEnum.enum_type)));
+		dbEnum.values.forEach((v) => {
+			const { name, modified } = resolveNameCasing(options.fieldCasing, v);
+			factory.addField((builder) => {
+				builder.setName(name);
+				if (modified || options.alwaysMap) builder.addAttribute((builder) => builder.setDecl(getAttributeRef("@map", services)).addArg((argBuilder) => argBuilder.StringLiteral.setValue(v)));
+				return builder;
+			});
+		});
+		if (dbEnum.schema_name && dbEnum.schema_name !== "" && dbEnum.schema_name !== defaultSchema) factory.addAttribute((b) => b.setDecl(getAttributeRef("@@schema", services)).addArg((a) => a.StringLiteral.setValue(dbEnum.schema_name)));
+		model.declarations.push(factory.get({ $container: model }));
+	}
+	else {
+		const dummyBuildReference = (_node, _property, _refNode, refText) => ({ $refText: refText });
+		oldModel.declarations.filter((d) => isEnum(d)).forEach((d) => {
+			const copy = AstUtils.copyAstNode(d, dummyBuildReference);
+			copy.$container = model;
+			model.declarations.push(copy);
+		});
+	}
+}
+function syncTable({ model, provider, table, services, options, defaultSchema }) {
+	const idAttribute = getAttributeRef("@id", services);
+	const modelIdAttribute = getAttributeRef("@@id", services);
+	const uniqueAttribute = getAttributeRef("@unique", services);
+	const modelUniqueAttribute = getAttributeRef("@@unique", services);
+	const fieldMapAttribute = getAttributeRef("@map", services);
+	const tableMapAttribute = getAttributeRef("@@map", services);
+	const modelindexAttribute = getAttributeRef("@@index", services);
+	const relations = [];
+	const { name, modified } = resolveNameCasing(options.modelCasing, table.name);
+	const multiPk = table.columns.filter((c) => c.pk).length > 1;
+	const modelFactory = new DataModelFactory().setName(name).setIsView(table.type === "view");
+	modelFactory.setContainer(model);
+	if (modified || options.alwaysMap) modelFactory.addAttribute((builder) => builder.setDecl(tableMapAttribute).addArg((argBuilder) => argBuilder.StringLiteral.setValue(table.name)));
+	const fkGroups = /* @__PURE__ */ new Map();
+	table.columns.forEach((column) => {
+		if (column.foreign_key_table && column.foreign_key_name) {
+			const group = fkGroups.get(column.foreign_key_name) ?? [];
+			group.push(column);
+			fkGroups.set(column.foreign_key_name, group);
+		}
+	});
+	for (const [fkName, fkColumns] of fkGroups) {
+		const firstCol = fkColumns[0];
+		const isSingleColumnPk = fkColumns.length === 1 && !multiPk && firstCol.pk;
+		const isUniqueRelation = fkColumns.length === 1 && firstCol.unique || isSingleColumnPk;
+		relations.push({
+			schema: table.schema,
+			table: table.name,
+			columns: fkColumns.map((c) => c.name),
+			type: "one",
+			fk_name: fkName,
+			foreign_key_on_delete: firstCol.foreign_key_on_delete,
+			foreign_key_on_update: firstCol.foreign_key_on_update,
+			nullable: firstCol.nullable,
+			references: {
+				schema: firstCol.foreign_key_schema,
+				table: firstCol.foreign_key_table,
+				columns: fkColumns.map((c) => c.foreign_key_column),
+				type: isUniqueRelation ? "one" : "many"
+			}
+		});
+	}
+	table.columns.forEach((column) => {
+		const { name, modified } = resolveNameCasing(options.fieldCasing, column.name);
+		const builtinType = provider.getBuiltinType(column.datatype);
+		modelFactory.addField((builder) => {
+			builder.setName(name);
+			builder.setType((typeBuilder) => {
+				typeBuilder.setArray(builtinType.isArray);
+				typeBuilder.setOptional(builtinType.isArray ? false : column.nullable);
+				if (column.computed) typeBuilder.setUnsupported((unsupportedBuilder) => unsupportedBuilder.setValue((lt) => lt.StringLiteral.setValue(column.datatype)));
+				else if (column.datatype === "enum") {
+					const ref = model.declarations.find((d) => isEnum(d) && getDbName(d) === column.datatype_name);
+					if (!ref) throw new CliError(`Enum ${column.datatype_name} not found`);
+					typeBuilder.setReference(ref);
+				} else if (builtinType.type !== "Unsupported") typeBuilder.setType(builtinType.type);
+				else typeBuilder.setUnsupported((unsupportedBuilder) => unsupportedBuilder.setValue((lt) => lt.StringLiteral.setValue(column.datatype)));
+				return typeBuilder;
+			});
+			if (column.pk && !multiPk) builder.addAttribute((b) => b.setDecl(idAttribute));
+			provider.getFieldAttributes({
+				fieldName: column.name,
+				fieldType: builtinType.type,
+				datatype: column.datatype,
+				length: column.length,
+				precision: column.precision,
+				services
+			}).forEach(builder.addAttribute.bind(builder));
+			if (column.default && !column.computed) {
+				const defaultExprBuilder = provider.getDefaultValue({
+					fieldType: builtinType.type,
+					datatype: column.datatype,
+					datatype_name: column.datatype_name,
+					defaultValue: column.default,
+					services,
+					enums: model.declarations.filter((d) => d.$type === "Enum")
+				});
+				if (defaultExprBuilder) {
+					const defaultAttr = new DataFieldAttributeFactory().setDecl(getAttributeRef("@default", services)).addArg(defaultExprBuilder);
+					builder.addAttribute(defaultAttr);
+				}
+			}
+			if (column.unique && !column.pk) builder.addAttribute((b) => {
+				b.setDecl(uniqueAttribute);
+				if (!(!column.unique_name || column.unique_name === `${table.name}_${column.name}_key` || column.unique_name === column.name)) b.addArg((ab) => ab.StringLiteral.setValue(column.unique_name), "map");
+				return b;
+			});
+			if (modified || options.alwaysMap) builder.addAttribute((ab) => ab.setDecl(fieldMapAttribute).addArg((ab) => ab.StringLiteral.setValue(column.name)));
+			return builder;
+		});
+	});
+	const pkColumns = table.columns.filter((c) => c.pk).map((c) => c.name);
+	if (multiPk) modelFactory.addAttribute((builder) => builder.setDecl(modelIdAttribute).addArg((argBuilder) => {
+		const arrayExpr = argBuilder.ArrayExpr;
+		pkColumns.forEach((c) => {
+			const ref = modelFactory.node.fields.find((f) => getDbName(f) === c);
+			if (!ref) throw new CliError(`Field ${c} not found`);
+			arrayExpr.addItem((itemBuilder) => itemBuilder.ReferenceExpr.setTarget(ref));
+		});
+		return arrayExpr;
+	}));
+	if (!(table.columns.some((c) => c.unique || c.pk) || table.indexes.some((i) => i.unique))) {
+		modelFactory.addAttribute((a) => a.setDecl(getAttributeRef("@@ignore", services)));
+		modelFactory.addComment("/// The underlying table does not contain a valid unique identifier and can therefore currently not be handled by Zenstack Client.");
+	}
+	table.indexes.reverse().sort((a, b) => {
+		if (a.unique && !b.unique) return -1;
+		if (!a.unique && b.unique) return 1;
+		return 0;
+	}).forEach((index) => {
+		if (index.predicate) {
+			console.warn(colors.yellow(`These constraints are not supported by Zenstack. Read more: https://pris.ly/d/check-constraints\n- Model: "${table.name}", constraint: "${index.name}"`));
+			return;
+		}
+		if (index.columns.find((c) => c.expression)) {
+			console.warn(colors.yellow(`These constraints are not supported by Zenstack. Read more: https://pris.ly/d/check-constraints\n- Model: "${table.name}", constraint: "${index.name}"`));
+			return;
+		}
+		if (index.primary) return;
+		if (index.columns.length === 1 && (index.columns.find((c) => pkColumns.includes(c.name)) || index.unique)) return;
+		modelFactory.addAttribute((builder) => {
+			const attr = builder.setDecl(index.unique ? modelUniqueAttribute : modelindexAttribute).addArg((argBuilder) => {
+				const arrayExpr = argBuilder.ArrayExpr;
+				index.columns.forEach((c) => {
+					const ref = modelFactory.node.fields.find((f) => getDbName(f) === c.name);
+					if (!ref) throw new CliError(`Column ${c.name} not found in model ${table.name}`);
+					arrayExpr.addItem((itemBuilder) => {
+						const refExpr = itemBuilder.ReferenceExpr.setTarget(ref);
+						if (c.order && c.order !== "ASC") refExpr.addArg((ab) => ab.StringLiteral.setValue("DESC"), "sort");
+						return refExpr;
+					});
+				});
+				return arrayExpr;
+			});
+			const suffix = index.unique ? "_key" : "_idx";
+			if (index.name !== `${table.name}_${index.columns.map((c) => c.name).join("_")}${suffix}`) attr.addArg((argBuilder) => argBuilder.StringLiteral.setValue(index.name), "map");
+			return attr;
+		});
+	});
+	if (table.schema && table.schema !== "" && table.schema !== defaultSchema) modelFactory.addAttribute((b) => b.setDecl(getAttributeRef("@@schema", services)).addArg((a) => a.StringLiteral.setValue(table.schema)));
+	model.declarations.push(modelFactory.node);
+	return relations;
+}
+function syncRelation({ model, relation, services, options, selfRelation, similarRelations }) {
+	const idAttribute = getAttributeRef("@id", services);
+	const uniqueAttribute = getAttributeRef("@unique", services);
+	const relationAttribute = getAttributeRef("@relation", services);
+	const fieldMapAttribute = getAttributeRef("@map", services);
+	const tableMapAttribute = getAttributeRef("@@map", services);
+	const includeRelationName = selfRelation || similarRelations > 0;
+	if (!idAttribute || !uniqueAttribute || !relationAttribute || !fieldMapAttribute || !tableMapAttribute) throw new CliError("Cannot find required attributes in the model.");
+	const sourceModel = model.declarations.find((d) => d.$type === "DataModel" && getDbName(d) === relation.table);
+	if (!sourceModel) return;
+	const sourceFields = [];
+	for (const colName of relation.columns) {
+		const idx = sourceModel.fields.findIndex((f) => getDbName(f) === colName);
+		const field = sourceModel.fields[idx];
+		if (!field) return;
+		sourceFields.push({
+			field,
+			index: idx
+		});
+	}
+	const targetModel = model.declarations.find((d) => d.$type === "DataModel" && getDbName(d) === relation.references.table);
+	if (!targetModel) return;
+	const targetFields = [];
+	for (const colName of relation.references.columns) {
+		const field = targetModel.fields.find((f) => getDbName(f) === colName);
+		if (!field) return;
+		targetFields.push(field);
+	}
+	const firstSourceField = sourceFields[0].field;
+	const firstSourceFieldId = sourceFields[0].index;
+	const firstColumn = relation.columns[0];
+	const fieldPrefix = /[0-9]/g.test(sourceModel.name.charAt(0)) ? "_" : "";
+	const relationName = `${relation.table}${similarRelations > 0 ? `_${firstColumn}` : ""}To${relation.references.table}`;
+	const sourceNameFromReference = firstSourceField.name.toLowerCase().endsWith("id") ? `${resolveNameCasing(options.fieldCasing, firstSourceField.name.slice(0, -2)).name}${relation.type === "many" ? "s" : ""}` : void 0;
+	const sourceFieldFromReference = sourceModel.fields.find((f) => f.name === sourceNameFromReference);
+	let { name: sourceFieldName } = resolveNameCasing(options.fieldCasing, similarRelations > 0 ? `${fieldPrefix}${lowerCaseFirst(sourceModel.name)}_${firstColumn}` : `${(!sourceFieldFromReference ? sourceNameFromReference : void 0) || lowerCaseFirst(resolveNameCasing(options.fieldCasing, targetModel.name).name)}${relation.type === "many" ? "s" : ""}`);
+	if (sourceModel.fields.find((f) => f.name === sourceFieldName)) sourceFieldName = `${sourceFieldName}To${lowerCaseFirst(targetModel.name)}_${relation.references.columns[0]}`;
+	const sourceFieldFactory = new DataFieldFactory().setContainer(sourceModel).setName(sourceFieldName).setType((tb) => tb.setOptional(relation.nullable).setArray(relation.type === "many").setReference(targetModel));
+	sourceFieldFactory.addAttribute((ab) => {
+		ab.setDecl(relationAttribute);
+		if (includeRelationName) ab.addArg((ab) => ab.StringLiteral.setValue(relationName));
+		ab.addArg((ab) => {
+			const arrayExpr = ab.ArrayExpr;
+			for (const { field } of sourceFields) arrayExpr.addItem((aeb) => aeb.ReferenceExpr.setTarget(field));
+			return arrayExpr;
+		}, "fields");
+		ab.addArg((ab) => {
+			const arrayExpr = ab.ArrayExpr;
+			for (const field of targetFields) arrayExpr.addItem((aeb) => aeb.ReferenceExpr.setTarget(field));
+			return arrayExpr;
+		}, "references");
+		const onDeleteDefault = relation.nullable ? "SET NULL" : "RESTRICT";
+		if (relation.foreign_key_on_delete && relation.foreign_key_on_delete !== onDeleteDefault) {
+			const enumRef = getEnumRef("ReferentialAction", services);
+			if (!enumRef) throw new CliError("ReferentialAction enum not found");
+			const enumFieldRef = enumRef.fields.find((f) => f.name.toLowerCase() === relation.foreign_key_on_delete.replace(/ /g, "").toLowerCase());
+			if (!enumFieldRef) throw new CliError(`ReferentialAction ${relation.foreign_key_on_delete} not found`);
+			ab.addArg((a) => a.ReferenceExpr.setTarget(enumFieldRef), "onDelete");
+		}
+		if (relation.foreign_key_on_update && relation.foreign_key_on_update !== "CASCADE") {
+			const enumRef = getEnumRef("ReferentialAction", services);
+			if (!enumRef) throw new CliError("ReferentialAction enum not found");
+			const enumFieldRef = enumRef.fields.find((f) => f.name.toLowerCase() === relation.foreign_key_on_update.replace(/ /g, "").toLowerCase());
+			if (!enumFieldRef) throw new CliError(`ReferentialAction ${relation.foreign_key_on_update} not found`);
+			ab.addArg((a) => a.ReferenceExpr.setTarget(enumFieldRef), "onUpdate");
+		}
+		const defaultFkName = `${relation.table}_${relation.columns.join("_")}_fkey`;
+		if (relation.fk_name && relation.fk_name !== defaultFkName) ab.addArg((ab) => ab.StringLiteral.setValue(relation.fk_name), "map");
+		return ab;
+	});
+	sourceModel.fields.splice(firstSourceFieldId, 0, sourceFieldFactory.node);
+	const oppositeFieldPrefix = /[0-9]/g.test(targetModel.name.charAt(0)) ? "_" : "";
+	let { name: oppositeFieldName } = resolveNameCasing(options.fieldCasing, similarRelations > 0 ? `${oppositeFieldPrefix}${lowerCaseFirst(sourceModel.name)}_${firstColumn}` : `${lowerCaseFirst(resolveNameCasing(options.fieldCasing, sourceModel.name).name)}${relation.references.type === "many" ? "s" : ""}`);
+	if (targetModel.fields.find((f) => f.name === oppositeFieldName)) ({name: oppositeFieldName} = resolveNameCasing(options.fieldCasing, `${lowerCaseFirst(sourceModel.name)}_${firstColumn}To${relation.references.table}_${relation.references.columns[0]}`));
+	const targetFieldFactory = new DataFieldFactory().setContainer(targetModel).setName(oppositeFieldName).setType((tb) => tb.setOptional(relation.references.type === "one").setArray(relation.references.type === "many").setReference(sourceModel));
+	if (includeRelationName) targetFieldFactory.addAttribute((ab) => ab.setDecl(relationAttribute).addArg((ab) => ab.StringLiteral.setValue(relationName)));
+	targetModel.fields.push(targetFieldFactory.node);
+}
+/**
+* Consolidates per-column enums back to shared enums when possible.
+*
+* MySQL doesn't have named enum types — each column gets a synthetic enum
+* (e.g., `UserStatus`, `GroupStatus`). When the original schema used a shared
+* enum (e.g., `Status`) across multiple fields, this function detects the
+* mapping via field references and consolidates the synthetic enums back into
+* the original shared enum so the merge phase can match them correctly.
+*/
+function consolidateEnums({ newModel, oldModel }) {
+	const newEnums = newModel.declarations.filter((d) => isEnum(d));
+	const newDataModels = newModel.declarations.filter((d) => d.$type === "DataModel");
+	const oldDataModels = oldModel.declarations.filter((d) => d.$type === "DataModel");
+	const enumMapping = /* @__PURE__ */ new Map();
+	for (const newEnum of newEnums) for (const newDM of newDataModels) {
+		for (const field of newDM.fields) {
+			if (field.$type !== "DataField" || field.type.reference?.ref !== newEnum) continue;
+			const oldDM = oldDataModels.find((d) => getDbName(d) === getDbName(newDM));
+			if (!oldDM) continue;
+			const oldField = oldDM.fields.find((f) => getDbName(f) === getDbName(field));
+			if (!oldField || oldField.$type !== "DataField" || !oldField.type.reference?.ref) continue;
+			const oldEnum = oldField.type.reference.ref;
+			if (!isEnum(oldEnum)) continue;
+			enumMapping.set(newEnum, oldEnum);
+			break;
+		}
+		if (enumMapping.has(newEnum)) break;
+	}
+	const reverseMapping = /* @__PURE__ */ new Map();
+	for (const [newEnum, oldEnum] of enumMapping) {
+		if (!reverseMapping.has(oldEnum)) reverseMapping.set(oldEnum, []);
+		reverseMapping.get(oldEnum).push(newEnum);
+	}
+	for (const [oldEnum, newEnumsGroup] of reverseMapping) {
+		const keepEnum = newEnumsGroup[0];
+		if (newEnumsGroup.length === 1 && keepEnum.name === oldEnum.name) continue;
+		const oldValues = new Set(oldEnum.fields.map((f) => getDbName(f)));
+		if (!newEnumsGroup.every((ne) => {
+			const newValues = new Set(ne.fields.map((f) => getDbName(f)));
+			return oldValues.size === newValues.size && [...oldValues].every((v) => newValues.has(v));
+		})) continue;
+		keepEnum.name = oldEnum.name;
+		keepEnum.attributes = oldEnum.attributes.map((attr) => {
+			return {
+				...attr,
+				$container: keepEnum
+			};
+		});
+		for (let i = 1; i < newEnumsGroup.length; i++) {
+			const idx = newModel.declarations.indexOf(newEnumsGroup[i]);
+			if (idx >= 0) newModel.declarations.splice(idx, 1);
+		}
+		for (const newDM of newDataModels) for (const field of newDM.fields) {
+			if (field.$type !== "DataField") continue;
+			const ref = field.type.reference?.ref;
+			if (ref && newEnumsGroup.includes(ref)) field.type.reference = {
+				ref: keepEnum,
+				$refText: keepEnum.name
+			};
+		}
+		console.log(colors.gray(`Consolidated enum${newEnumsGroup.length > 1 ? "s" : ""} ${newEnumsGroup.map((e) => e.name).join(", ")} → ${oldEnum.name}`));
+	}
+}
+//#endregion
+//#region src/actions/pull/provider/mysql.ts
+function normalizeGenerationExpression(typeDef) {
+	return typeDef.replace(/_([0-9A-Za-z_]+)\\?'/g, "'").replace(/\\'/g, "'");
+}
+const mysql = {
+	isSupportedFeature(feature) {
+		switch (feature) {
+			case "NativeEnum": return true;
+			default: return false;
+		}
+	},
+	getBuiltinType(type) {
+		const t = (type || "").toLowerCase().trim();
+		const isArray = false;
+		switch (t) {
+			case "tinyint":
+			case "smallint":
+			case "mediumint":
+			case "int":
+			case "integer": return {
+				type: "Int",
+				isArray
+			};
+			case "bigint": return {
+				type: "BigInt",
+				isArray
+			};
+			case "decimal":
+			case "numeric": return {
+				type: "Decimal",
+				isArray
+			};
+			case "float":
+			case "double":
+			case "real": return {
+				type: "Float",
+				isArray
+			};
+			case "boolean":
+			case "bool": return {
+				type: "Boolean",
+				isArray
+			};
+			case "char":
+			case "varchar":
+			case "tinytext":
+			case "text":
+			case "mediumtext":
+			case "longtext": return {
+				type: "String",
+				isArray
+			};
+			case "date":
+			case "time":
+			case "datetime":
+			case "timestamp":
+			case "year": return {
+				type: "DateTime",
+				isArray
+			};
+			case "binary":
+			case "varbinary":
+			case "tinyblob":
+			case "blob":
+			case "mediumblob":
+			case "longblob": return {
+				type: "Bytes",
+				isArray
+			};
+			case "json": return {
+				type: "Json",
+				isArray
+			};
+			default:
+				if (t.startsWith("enum(")) return {
+					type: "String",
+					isArray
+				};
+				if (t.startsWith("set(")) return {
+					type: "String",
+					isArray
+				};
+				return {
+					type: "Unsupported",
+					isArray
+				};
+		}
+	},
+	getDefaultDatabaseType(type) {
+		switch (type) {
+			case "String": return {
+				type: "varchar",
+				precision: 191
+			};
+			case "Boolean": return { type: "boolean" };
+			case "Int": return { type: "int" };
+			case "BigInt": return { type: "bigint" };
+			case "Float": return { type: "double" };
+			case "Decimal": return {
+				type: "decimal",
+				precision: 65
+			};
+			case "DateTime": return {
+				type: "datetime",
+				precision: 3
+			};
+			case "Json": return { type: "json" };
+			case "Bytes": return { type: "longblob" };
+		}
+	},
+	async introspect(connectionString, options) {
+		const connection = await (await import("mysql2/promise")).createConnection(connectionString);
+		try {
+			const databaseName = new URL(connectionString).pathname.replace("/", "");
+			if (!databaseName) throw new CliError("Database name not found in connection string");
+			const [tableRows] = await connection.execute(getTableIntrospectionQuery(), [databaseName]);
+			const tables = [];
+			for (const row of tableRows) {
+				const columns = typeof row.columns === "string" ? JSON.parse(row.columns) : row.columns;
+				const indexes = typeof row.indexes === "string" ? JSON.parse(row.indexes) : row.indexes;
+				const sortedColumns = (columns || []).sort((a, b) => (a.ordinal_position ?? 0) - (b.ordinal_position ?? 0)).map((col) => {
+					if (col.datatype === "enum" && col.datatype_name) return {
+						...col,
+						datatype_name: resolveNameCasing(options.modelCasing, col.datatype_name).name
+					};
+					if (col.computed && typeof col.datatype === "string") return {
+						...col,
+						datatype: normalizeGenerationExpression(col.datatype)
+					};
+					return col;
+				});
+				const filteredIndexes = (indexes || []).filter((idx) => !(idx.columns.length === 1 && idx.name === `${row.name}_${idx.columns[0]?.name}_fkey`));
+				tables.push({
+					schema: "",
+					name: row.name,
+					type: row.type,
+					definition: row.definition,
+					columns: sortedColumns,
+					indexes: filteredIndexes
+				});
+			}
+			const [enumRows] = await connection.execute(getEnumIntrospectionQuery(), [databaseName]);
+			return {
+				tables,
+				enums: enumRows.map((row) => {
+					const values = parseEnumValues(row.column_type);
+					const syntheticName = `${row.table_name}_${row.column_name}`;
+					const { name } = resolveNameCasing(options.modelCasing, syntheticName);
+					return {
+						schema_name: "",
+						enum_type: name,
+						values
+					};
+				})
+			};
+		} finally {
+			await connection.end();
+		}
+	},
+	getDefaultValue({ defaultValue, fieldType, datatype, datatype_name, services, enums }) {
+		const val = defaultValue.trim();
+		if (val.toUpperCase() === "NULL") return null;
+		if (datatype === "enum" && datatype_name) {
+			const enumDef = enums.find((e) => getDbName(e) === datatype_name);
+			if (enumDef) {
+				const enumValue = val.startsWith("'") && val.endsWith("'") ? val.slice(1, -1) : val;
+				const enumField = enumDef.fields.find((f) => getDbName(f) === enumValue);
+				if (enumField) return (ab) => ab.ReferenceExpr.setTarget(enumField);
+			}
+		}
+		switch (fieldType) {
+			case "DateTime":
+				if (/^CURRENT_TIMESTAMP(\(\d*\))?$/i.test(val) || val.toLowerCase() === "current_timestamp()" || val.toLowerCase() === "now()") return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("now", services));
+				return (ab) => ab.StringLiteral.setValue(val);
+			case "Int":
+			case "BigInt":
+				if (val.toLowerCase() === "auto_increment") return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("autoincrement", services));
+				return (ab) => ab.NumberLiteral.setValue(val);
+			case "Float": return normalizeFloatDefault(val);
+			case "Decimal": return normalizeDecimalDefault(val);
+			case "Boolean": return (ab) => ab.BooleanLiteral.setValue(val.toLowerCase() === "true" || val === "1" || val === "b'1'");
+			case "String":
+				if (val.toLowerCase() === "uuid()") return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("uuid", services));
+				return (ab) => ab.StringLiteral.setValue(val);
+			case "Json": return (ab) => ab.StringLiteral.setValue(val);
+			case "Bytes": return (ab) => ab.StringLiteral.setValue(val);
+		}
+		if (val.includes("(") && val.includes(")")) return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("dbgenerated", services)).addArg((a) => a.setValue((v) => v.StringLiteral.setValue(val)));
+		console.warn(`Unsupported default value type: "${defaultValue}" for field type "${fieldType}". Skipping default value.`);
+		return null;
+	},
+	getFieldAttributes({ fieldName, fieldType, datatype, length, precision, services }) {
+		const factories = [];
+		if (fieldType === "DateTime" && (fieldName.toLowerCase() === "updatedat" || fieldName.toLowerCase() === "updated_at")) factories.push(new DataFieldAttributeFactory().setDecl(getAttributeRef("@updatedAt", services)));
+		const dbAttr = services.shared.workspace.IndexManager.allElements("Attribute").find((d) => d.name.toLowerCase() === `@db.${datatype.toLowerCase()}`)?.node;
+		const defaultDatabaseType = this.getDefaultDatabaseType(fieldType);
+		if (dbAttr && defaultDatabaseType && (defaultDatabaseType.type !== datatype || defaultDatabaseType.precision && defaultDatabaseType.precision !== (length ?? precision))) {
+			const dbAttrFactory = new DataFieldAttributeFactory().setDecl(dbAttr);
+			const sizeValue = length ?? precision;
+			if (sizeValue !== void 0 && sizeValue !== null) dbAttrFactory.addArg((a) => a.NumberLiteral.setValue(sizeValue));
+			factories.push(dbAttrFactory);
+		}
+		return factories;
+	}
+};
+function getTableIntrospectionQuery() {
+	return `
+-- Main query: one row per table/view with columns and indexes as nested JSON arrays.
+-- Uses INFORMATION_SCHEMA which is MySQL's standard metadata catalog.
+SELECT
+    t.TABLE_NAME AS \`name\`,              -- table or view name
+    CASE t.TABLE_TYPE                      -- map MySQL table type strings to our internal types
+        WHEN 'BASE TABLE' THEN 'table'
+        WHEN 'VIEW' THEN 'view'
+        ELSE NULL
+    END AS \`type\`,
+    CASE                                   -- for views, retrieve the SQL definition
+        WHEN t.TABLE_TYPE = 'VIEW' THEN v.VIEW_DEFINITION
+        ELSE NULL
+    END AS \`definition\`,
+
+    -- ===== COLUMNS subquery =====
+    -- Wraps an ordered subquery in JSON_ARRAYAGG to produce a JSON array of column objects.
+    (
+        SELECT JSON_ARRAYAGG(col_json)
+        FROM (
+            SELECT JSON_OBJECT(
+                'ordinal_position', c.ORDINAL_POSITION,  -- column position (used for sorting)
+                'name', c.COLUMN_NAME,                    -- column name
+
+                -- datatype: for generated/computed columns, construct the full DDL-like type definition
+                -- (e.g., "int GENERATED ALWAYS AS (col1 + col2) STORED") so it can be rendered as
+                -- Unsupported("..."); special-case tinyint(1) as 'boolean' (MySQL's boolean convention);
+                -- otherwise use the DATA_TYPE (e.g., 'int', 'varchar', 'datetime').
+                'datatype', CASE
+                    WHEN c.GENERATION_EXPRESSION IS NOT NULL AND c.GENERATION_EXPRESSION != '' THEN
+                        CONCAT(
+                            c.COLUMN_TYPE,
+                            ' GENERATED ALWAYS AS (',
+                            c.GENERATION_EXPRESSION,
+                            ') ',
+                            CASE
+                                WHEN c.EXTRA LIKE '%STORED GENERATED%' THEN 'STORED'
+                                ELSE 'VIRTUAL'
+                            END
+                        )
+                    WHEN c.DATA_TYPE = 'tinyint' AND c.COLUMN_TYPE = 'tinyint(1)' THEN 'boolean'
+                    ELSE c.DATA_TYPE
+                END,
+
+                -- datatype_name: for enum columns, generate a synthetic name "TableName_ColumnName"
+                -- (MySQL doesn't have named enum types like PostgreSQL)
+                'datatype_name', CASE
+                    WHEN c.DATA_TYPE = 'enum' THEN CONCAT(t.TABLE_NAME, '_', c.COLUMN_NAME)
+                    ELSE NULL
+                END,
+
+                'datatype_schema', '',                     -- MySQL doesn't support multi-schema
+                'length', c.CHARACTER_MAXIMUM_LENGTH,      -- max length for string types (e.g., VARCHAR(255) -> 255)
+                'precision', COALESCE(c.NUMERIC_PRECISION, c.DATETIME_PRECISION),  -- numeric or datetime precision
+
+                'nullable', c.IS_NULLABLE = 'YES',         -- true if column allows NULL
+
+                -- default: for auto_increment columns, report 'auto_increment' instead of NULL;
+                -- otherwise use the COLUMN_DEFAULT value
+                'default', CASE
+                    WHEN c.EXTRA LIKE '%auto_increment%' THEN 'auto_increment'
+                    ELSE c.COLUMN_DEFAULT
+                END,
+
+                'pk', c.COLUMN_KEY = 'PRI',                -- true if column is part of the primary key
+
+                -- unique: true if the column has a single-column unique index.
+                -- COLUMN_KEY = 'UNI' covers most cases, but may not be set when the column
+                -- also participates in other indexes (showing 'MUL' instead on some MySQL versions).
+                -- Also check INFORMATION_SCHEMA.STATISTICS for single-column unique indexes
+                -- (NON_UNIQUE = 0) to match the PostgreSQL introspection behavior.
+                'unique', (
+                    c.COLUMN_KEY = 'UNI'
+                    OR EXISTS (
+                        SELECT 1
+                        FROM INFORMATION_SCHEMA.STATISTICS s_uni
+                        WHERE s_uni.TABLE_SCHEMA = c.TABLE_SCHEMA
+                            AND s_uni.TABLE_NAME = c.TABLE_NAME
+                            AND s_uni.COLUMN_NAME = c.COLUMN_NAME
+                            AND s_uni.NON_UNIQUE = 0
+                            AND s_uni.INDEX_NAME != 'PRIMARY'
+                            AND (
+                                SELECT COUNT(*)
+                                FROM INFORMATION_SCHEMA.STATISTICS s_cnt
+                                WHERE s_cnt.TABLE_SCHEMA = s_uni.TABLE_SCHEMA
+                                    AND s_cnt.TABLE_NAME = s_uni.TABLE_NAME
+                                    AND s_cnt.INDEX_NAME = s_uni.INDEX_NAME
+                            ) = 1
+                    )
+                ),
+                'unique_name', (
+                    SELECT COALESCE(
+                        CASE WHEN c.COLUMN_KEY = 'UNI' THEN c.COLUMN_NAME ELSE NULL END,
+                        (
+                            SELECT s_uni.INDEX_NAME
+                            FROM INFORMATION_SCHEMA.STATISTICS s_uni
+                            WHERE s_uni.TABLE_SCHEMA = c.TABLE_SCHEMA
+                                AND s_uni.TABLE_NAME = c.TABLE_NAME
+                                AND s_uni.COLUMN_NAME = c.COLUMN_NAME
+                                AND s_uni.NON_UNIQUE = 0
+                                AND s_uni.INDEX_NAME != 'PRIMARY'
+                                AND (
+                                    SELECT COUNT(*)
+                                    FROM INFORMATION_SCHEMA.STATISTICS s_cnt
+                                    WHERE s_cnt.TABLE_SCHEMA = s_uni.TABLE_SCHEMA
+                                        AND s_cnt.TABLE_NAME = s_uni.TABLE_NAME
+                                        AND s_cnt.INDEX_NAME = s_uni.INDEX_NAME
+                                ) = 1
+                            LIMIT 1
+                        )
+                    )
+                ),
+
+                -- computed: true if column has a generation expression (virtual or stored)
+                'computed', c.GENERATION_EXPRESSION IS NOT NULL AND c.GENERATION_EXPRESSION != '',
+
+                -- options: for enum columns, the full COLUMN_TYPE string (e.g., "enum('a','b','c')")
+                -- which gets parsed into individual values later
+                'options', CASE
+                    WHEN c.DATA_TYPE = 'enum' THEN c.COLUMN_TYPE
+                    ELSE NULL
+                END,
+
+                -- Foreign key info (NULL if column is not part of a FK)
+                'foreign_key_schema', NULL,                 -- MySQL doesn't support cross-schema FKs here
+                'foreign_key_table', kcu_fk.REFERENCED_TABLE_NAME,   -- referenced table
+                'foreign_key_column', kcu_fk.REFERENCED_COLUMN_NAME, -- referenced column
+                'foreign_key_name', kcu_fk.CONSTRAINT_NAME,          -- FK constraint name
+                'foreign_key_on_update', rc.UPDATE_RULE,    -- referential action on update (CASCADE, SET NULL, etc.)
+                'foreign_key_on_delete', rc.DELETE_RULE      -- referential action on delete
+            ) AS col_json
+
+            FROM INFORMATION_SCHEMA.COLUMNS c  -- one row per column in the database
+
+            -- Join KEY_COLUMN_USAGE to find foreign key references for this column.
+            -- Filter to only FK entries (REFERENCED_TABLE_NAME IS NOT NULL).
+            LEFT JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu_fk
+                ON c.TABLE_SCHEMA = kcu_fk.TABLE_SCHEMA
+                AND c.TABLE_NAME = kcu_fk.TABLE_NAME
+                AND c.COLUMN_NAME = kcu_fk.COLUMN_NAME
+                AND kcu_fk.REFERENCED_TABLE_NAME IS NOT NULL
+
+            -- Join REFERENTIAL_CONSTRAINTS to get ON UPDATE / ON DELETE rules for the FK.
+            LEFT JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
+                ON kcu_fk.CONSTRAINT_SCHEMA = rc.CONSTRAINT_SCHEMA
+                AND kcu_fk.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
+
+            WHERE c.TABLE_SCHEMA = t.TABLE_SCHEMA
+                AND c.TABLE_NAME = t.TABLE_NAME
+            ORDER BY c.ORDINAL_POSITION        -- preserve original column order
+        ) AS cols_ordered
+    ) AS \`columns\`,
+
+    -- ===== INDEXES subquery =====
+    -- Aggregates all indexes for this table into a JSON array.
+    (
+        SELECT JSON_ARRAYAGG(idx_json)
+        FROM (
+            SELECT JSON_OBJECT(
+                'name', s.INDEX_NAME,          -- index name (e.g., 'PRIMARY', 'idx_email')
+                'method', s.INDEX_TYPE,         -- index type (e.g., 'BTREE', 'HASH', 'FULLTEXT')
+                'unique', s.NON_UNIQUE = 0,    -- NON_UNIQUE=0 means it IS unique
+                'primary', s.INDEX_NAME = 'PRIMARY',  -- MySQL names the PK index 'PRIMARY'
+                'valid', TRUE,                  -- MySQL doesn't expose index validity status
+                'ready', TRUE,                  -- MySQL doesn't expose index readiness status
+                'partial', FALSE,               -- MySQL doesn't support partial indexes
+                'predicate', NULL,              -- no WHERE clause on indexes in MySQL
+
+                -- Index columns: nested subquery for columns in this index
+                'columns', (
+                    SELECT JSON_ARRAYAGG(idx_col_json)
+                    FROM (
+                        SELECT JSON_OBJECT(
+                            'name', s2.COLUMN_NAME,           -- column name in the index
+                            'expression', NULL,               -- MySQL doesn't expose expression indexes via STATISTICS
+                            -- COLLATION: 'A' = ascending, 'D' = descending, NULL = not sorted
+                            'order', CASE s2.COLLATION WHEN 'A' THEN 'ASC' WHEN 'D' THEN 'DESC' ELSE NULL END,
+                            'nulls', NULL                     -- MySQL doesn't expose NULLS FIRST/LAST
+                        ) AS idx_col_json
+                        FROM INFORMATION_SCHEMA.STATISTICS s2  -- one row per column per index
+                        WHERE s2.TABLE_SCHEMA = s.TABLE_SCHEMA
+                            AND s2.TABLE_NAME = s.TABLE_NAME
+                            AND s2.INDEX_NAME = s.INDEX_NAME
+                        ORDER BY s2.SEQ_IN_INDEX              -- preserve column order within the index
+                    ) AS idx_cols_ordered
+                )
+            ) AS idx_json
+            FROM (
+                -- Deduplicate: STATISTICS has one row per (index, column), but we need one row per index.
+                -- DISTINCT on INDEX_NAME gives us one entry per index with its metadata.
+                SELECT DISTINCT INDEX_NAME, INDEX_TYPE, NON_UNIQUE, TABLE_SCHEMA, TABLE_NAME
+                FROM INFORMATION_SCHEMA.STATISTICS
+                WHERE TABLE_SCHEMA = t.TABLE_SCHEMA AND TABLE_NAME = t.TABLE_NAME
+            ) s
+        ) AS idxs_ordered
+    ) AS \`indexes\`
+
+-- === Main FROM: INFORMATION_SCHEMA.TABLES lists all tables and views ===
+FROM INFORMATION_SCHEMA.TABLES t
+-- Join VIEWS to get VIEW_DEFINITION for view tables
+LEFT JOIN INFORMATION_SCHEMA.VIEWS v
+    ON t.TABLE_SCHEMA = v.TABLE_SCHEMA AND t.TABLE_NAME = v.TABLE_NAME
+WHERE t.TABLE_SCHEMA = ?                              -- only the target database
+    AND t.TABLE_TYPE IN ('BASE TABLE', 'VIEW')        -- exclude system tables like SYSTEM VIEW
+    AND t.TABLE_NAME <> '_prisma_migrations'           -- exclude Prisma migration tracking table
+ORDER BY t.TABLE_NAME;
+`;
+}
+function getEnumIntrospectionQuery() {
+	return `
+SELECT
+    c.TABLE_NAME AS table_name,    -- table containing the enum column
+    c.COLUMN_NAME AS column_name,  -- column name
+    c.COLUMN_TYPE AS column_type   -- full type string including values (e.g., "enum('val1','val2')")
+FROM INFORMATION_SCHEMA.COLUMNS c
+WHERE c.TABLE_SCHEMA = ?                   -- only the target database
+    AND c.DATA_TYPE = 'enum'               -- only enum columns
+ORDER BY c.TABLE_NAME, c.COLUMN_NAME;
+`;
+}
+/**
+* Parse enum values from MySQL COLUMN_TYPE string like "enum('val1','val2','val3')"
+*/
+function parseEnumValues(columnType) {
+	const match = columnType.match(/^enum\((.+)\)$/i);
+	if (!match || !match[1]) return [];
+	const valuesString = match[1];
+	const values = [];
+	let current = "";
+	let inQuote = false;
+	let i = 0;
+	while (i < valuesString.length) {
+		const char = valuesString[i];
+		if (char === "'" && !inQuote) {
+			inQuote = true;
+			i++;
+			continue;
+		}
+		if (char === "'" && inQuote) {
+			if (valuesString[i + 1] === "'") {
+				current += "'";
+				i += 2;
+				continue;
+			}
+			values.push(current);
+			current = "";
+			inQuote = false;
+			i++;
+			while (i < valuesString.length && (valuesString[i] === "," || valuesString[i] === " ")) i++;
+			continue;
+		}
+		if (inQuote) current += char;
+		i++;
+	}
+	return values;
+}
+//#endregion
+//#region src/actions/pull/provider/postgresql.ts
+/**
+* Maps PostgreSQL internal type names to their standard SQL names for comparison.
+* This is used to normalize type names when checking against default database types.
+*/
+const pgTypnameToStandard = {
+	int2: "smallint",
+	int4: "integer",
+	int8: "bigint",
+	float4: "real",
+	float8: "double precision",
+	bool: "boolean",
+	bpchar: "character",
+	numeric: "decimal"
+};
+/**
+* Standard bit widths for integer/float types that shouldn't be added as precision arguments.
+* PostgreSQL returns these as precision values, but they're implicit for the type.
+*/
+const standardTypePrecisions = {
+	int2: 16,
+	smallint: 16,
+	int4: 32,
+	integer: 32,
+	int8: 64,
+	bigint: 64,
+	float4: 24,
+	real: 24,
+	float8: 53,
+	"double precision": 53
+};
+/**
+* Maps PostgreSQL typnames (from pg_type.typname) to ZenStack native type attribute names.
+* PostgreSQL introspection returns internal type names like 'int2', 'int4', 'float8', 'bpchar',
+* but ZenStack attributes are named @db.SmallInt, @db.Integer, @db.DoublePrecision, @db.Char, etc.
+*/
+const pgTypnameToZenStackNativeType = {
+	int2: "SmallInt",
+	smallint: "SmallInt",
+	int4: "Integer",
+	integer: "Integer",
+	int8: "BigInt",
+	bigint: "BigInt",
+	numeric: "Decimal",
+	decimal: "Decimal",
+	float4: "Real",
+	real: "Real",
+	float8: "DoublePrecision",
+	"double precision": "DoublePrecision",
+	bool: "Boolean",
+	boolean: "Boolean",
+	text: "Text",
+	varchar: "VarChar",
+	"character varying": "VarChar",
+	bpchar: "Char",
+	character: "Char",
+	uuid: "Uuid",
+	date: "Date",
+	time: "Time",
+	timetz: "Timetz",
+	timestamp: "Timestamp",
+	timestamptz: "Timestamptz",
+	bytea: "ByteA",
+	json: "Json",
+	jsonb: "JsonB",
+	xml: "Xml",
+	inet: "Inet",
+	bit: "Bit",
+	varbit: "VarBit",
+	oid: "Oid",
+	money: "Money",
+	citext: "Citext"
+};
+const postgresql = {
+	isSupportedFeature(feature) {
+		return ["Schema", "NativeEnum"].includes(feature);
+	},
+	getBuiltinType(type) {
+		const t = (type || "").toLowerCase();
+		const isArray = t.startsWith("_");
+		switch (t.replace(/^_/, "")) {
+			case "int2":
+			case "smallint":
+			case "int4":
+			case "integer": return {
+				type: "Int",
+				isArray
+			};
+			case "int8":
+			case "bigint": return {
+				type: "BigInt",
+				isArray
+			};
+			case "numeric":
+			case "decimal": return {
+				type: "Decimal",
+				isArray
+			};
+			case "float4":
+			case "real":
+			case "float8":
+			case "double precision": return {
+				type: "Float",
+				isArray
+			};
+			case "bool":
+			case "boolean": return {
+				type: "Boolean",
+				isArray
+			};
+			case "text":
+			case "varchar":
+			case "bpchar":
+			case "character varying":
+			case "character": return {
+				type: "String",
+				isArray
+			};
+			case "uuid": return {
+				type: "String",
+				isArray
+			};
+			case "date":
+			case "time":
+			case "timetz":
+			case "timestamp":
+			case "timestamptz": return {
+				type: "DateTime",
+				isArray
+			};
+			case "bytea": return {
+				type: "Bytes",
+				isArray
+			};
+			case "json":
+			case "jsonb": return {
+				type: "Json",
+				isArray
+			};
+			default: return {
+				type: "Unsupported",
+				isArray
+			};
+		}
+	},
+	async introspect(connectionString, options) {
+		const { Client } = await import("pg");
+		const client = new Client({ connectionString });
+		await client.connect();
+		try {
+			const { rows: tables } = await client.query(tableIntrospectionQuery);
+			const { rows: enums } = await client.query(enumIntrospectionQuery);
+			const filteredTables = tables.filter((t) => options.schemas.includes(t.schema));
+			return {
+				enums: enums.filter((e) => options.schemas.includes(e.schema_name)),
+				tables: filteredTables
+			};
+		} finally {
+			await client.end();
+		}
+	},
+	getDefaultDatabaseType(type) {
+		switch (type) {
+			case "String": return { type: "text" };
+			case "Boolean": return { type: "boolean" };
+			case "Int": return { type: "integer" };
+			case "BigInt": return { type: "bigint" };
+			case "Float": return { type: "double precision" };
+			case "Decimal": return { type: "decimal" };
+			case "DateTime": return {
+				type: "timestamp",
+				precision: 3
+			};
+			case "Json": return { type: "jsonb" };
+			case "Bytes": return { type: "bytea" };
+		}
+	},
+	getDefaultValue({ defaultValue, fieldType, datatype, datatype_name, services, enums }) {
+		const val = defaultValue.trim();
+		if (datatype === "enum" && datatype_name) {
+			const enumDef = enums.find((e) => getDbName(e) === datatype_name);
+			if (enumDef) {
+				const enumValue = val.replace(/'/g, "").split("::")[0]?.trim();
+				const enumField = enumDef.fields.find((f) => getDbName(f) === enumValue);
+				if (enumField) return (ab) => ab.ReferenceExpr.setTarget(enumField);
+			}
+			return typeCastingConvert({
+				defaultValue,
+				enums,
+				val,
+				services
+			});
+		}
+		switch (fieldType) {
+			case "DateTime":
+				if (val === "CURRENT_TIMESTAMP" || val === "now()") return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("now", services));
+				if (val.includes("::")) return typeCastingConvert({
+					defaultValue,
+					enums,
+					val,
+					services
+				});
+				return (ab) => ab.StringLiteral.setValue(val);
+			case "Int":
+			case "BigInt":
+				if (val.startsWith("nextval(")) return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("autoincrement", services));
+				if (val.includes("::")) return typeCastingConvert({
+					defaultValue,
+					enums,
+					val,
+					services
+				});
+				return (ab) => ab.NumberLiteral.setValue(val);
+			case "Float":
+				if (val.includes("::")) return typeCastingConvert({
+					defaultValue,
+					enums,
+					val,
+					services
+				});
+				return normalizeFloatDefault(val);
+			case "Decimal":
+				if (val.includes("::")) return typeCastingConvert({
+					defaultValue,
+					enums,
+					val,
+					services
+				});
+				return normalizeDecimalDefault(val);
+			case "Boolean": return (ab) => ab.BooleanLiteral.setValue(val === "true");
+			case "String":
+				if (val.includes("::")) return typeCastingConvert({
+					defaultValue,
+					enums,
+					val,
+					services
+				});
+				if (val.startsWith("'") && val.endsWith("'")) return (ab) => ab.StringLiteral.setValue(val.slice(1, -1).replace(/''/g, "'"));
+				return (ab) => ab.StringLiteral.setValue(val);
+			case "Json":
+				if (val.includes("::")) return typeCastingConvert({
+					defaultValue,
+					enums,
+					val,
+					services
+				});
+				return (ab) => ab.StringLiteral.setValue(val);
+			case "Bytes":
+				if (val.includes("::")) return typeCastingConvert({
+					defaultValue,
+					enums,
+					val,
+					services
+				});
+				return (ab) => ab.StringLiteral.setValue(val);
+		}
+		if (val.includes("(") && val.includes(")")) return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("dbgenerated", services)).addArg((a) => a.setValue((v) => v.StringLiteral.setValue(val)));
+		console.warn(`Unsupported default value type: "${defaultValue}" for field type "${fieldType}". Skipping default value.`);
+		return null;
+	},
+	getFieldAttributes({ fieldName, fieldType, datatype, length, precision, services }) {
+		const factories = [];
+		if (fieldType === "DateTime" && (fieldName.toLowerCase() === "updatedat" || fieldName.toLowerCase() === "updated_at")) factories.push(new DataFieldAttributeFactory().setDecl(getAttributeRef("@updatedAt", services)));
+		const nativeTypeName = pgTypnameToZenStackNativeType[datatype.toLowerCase()] ?? datatype;
+		const dbAttr = services.shared.workspace.IndexManager.allElements("Attribute").find((d) => d.name.toLowerCase() === `@db.${nativeTypeName.toLowerCase()}`)?.node;
+		const defaultDatabaseType = this.getDefaultDatabaseType(fieldType);
+		const normalizedDatatype = pgTypnameToStandard[datatype.toLowerCase()] ?? datatype.toLowerCase();
+		const standardPrecision = standardTypePrecisions[datatype.toLowerCase()];
+		const isStandardPrecision = standardPrecision !== void 0 && precision === standardPrecision;
+		if (dbAttr && defaultDatabaseType && (defaultDatabaseType.type !== normalizedDatatype || defaultDatabaseType.precision && defaultDatabaseType.precision !== (length ?? precision))) {
+			const dbAttrFactory = new DataFieldAttributeFactory().setDecl(dbAttr);
+			if ((length || precision) && !isStandardPrecision) dbAttrFactory.addArg((a) => a.NumberLiteral.setValue(length || precision));
+			factories.push(dbAttrFactory);
+		}
+		return factories;
+	}
+};
+const enumIntrospectionQuery = `
+SELECT
+  n.nspname AS schema_name,          -- schema the enum belongs to (e.g., 'public')
+  t.typname AS enum_type,            -- enum type name as defined in CREATE TYPE
+  coalesce(json_agg(e.enumlabel ORDER BY e.enumsortorder), '[]') AS values  -- ordered list of enum labels as JSON array
+FROM pg_type t                        -- pg_type: catalog of all data types
+JOIN pg_enum e ON t.oid = e.enumtypid -- pg_enum: one row per enum label; join to get labels for this enum type
+JOIN pg_namespace n ON n.oid = t.typnamespace  -- pg_namespace: schema info; join to get the schema name
+GROUP BY schema_name, enum_type       -- one row per enum type, with all labels aggregated
+ORDER BY schema_name, enum_type;`;
+const tableIntrospectionQuery = `
+-- Main query: one row per table/view with columns and indexes as nested JSON arrays.
+-- Joins pg_class (tables/views) with pg_namespace (schemas).
+SELECT
+  "ns"."nspname" AS "schema",           -- schema name (e.g., 'public')
+  "cls"."relname" AS "name",            -- table or view name
+  CASE "cls"."relkind"                  -- relkind: 'r' = ordinary table, 'v' = view
+    WHEN 'r' THEN 'table'
+    WHEN 'v' THEN 'view'
+    ELSE NULL
+  END AS "type",
+  CASE                                  -- for views, retrieve the SQL definition
+    WHEN "cls"."relkind" = 'v' THEN pg_get_viewdef("cls"."oid", true)
+    ELSE NULL
+  END AS "definition",
+
+  -- ===== COLUMNS subquery =====
+  -- Aggregates all columns for this table into a JSON array.
+  (
+    SELECT coalesce(json_agg(agg), '[]')
+    FROM (
+      SELECT
+        "att"."attname" AS "name",       -- column name
+
+        -- datatype: if the type is an enum, report 'enum';
+        -- if the column is generated/computed, construct the full DDL-like type definition
+        -- (e.g., "text GENERATED ALWAYS AS (expr) STORED") so it can be rendered as Unsupported("...");
+        -- otherwise use the pg_type name.
+        CASE
+          WHEN EXISTS (
+            SELECT 1 FROM "pg_catalog"."pg_enum" AS "e"
+            WHERE "e"."enumtypid" = "typ"."oid"
+          ) THEN 'enum'
+          WHEN "att"."attgenerated" != '' THEN
+            format_type("att"."atttypid", "att"."atttypmod")
+            || ' GENERATED ALWAYS AS ('
+            || pg_get_expr("def"."adbin", "def"."adrelid")
+            || ') '
+            || CASE "att"."attgenerated"
+                 WHEN 's' THEN 'STORED'
+                 WHEN 'v' THEN 'VIRTUAL'
+                 ELSE 'STORED'
+               END
+          ELSE "typ"."typname"::text     -- internal type name (e.g., 'int4', 'varchar', 'text'); cast to text to prevent CASE from coercing result to name type (max 63 chars)
+        END AS "datatype",
+
+        -- datatype_name: for enums only, the actual enum type name (used to look up the enum definition)
+        CASE
+          WHEN EXISTS (
+            SELECT 1 FROM "pg_catalog"."pg_enum" AS "e"
+            WHERE "e"."enumtypid" = "typ"."oid"
+          ) THEN "typ"."typname"
+          ELSE NULL
+        END AS "datatype_name",
+
+        "tns"."nspname" AS "datatype_schema",  -- schema where the data type is defined
+        "c"."character_maximum_length" AS "length",  -- max length for char/varchar types (from information_schema)
+        COALESCE("c"."numeric_precision", "c"."datetime_precision") AS "precision",  -- numeric or datetime precision
+
+        -- Foreign key info (NULL if column is not part of a FK constraint)
+        "fk_ns"."nspname" AS "foreign_key_schema",   -- schema of the referenced table
+        "fk_cls"."relname" AS "foreign_key_table",    -- referenced table name
+        "fk_att"."attname" AS "foreign_key_column",   -- referenced column name
+        "fk_con"."conname" AS "foreign_key_name",     -- FK constraint name
+
+        -- FK referential actions: decode single-char codes to human-readable strings
+        CASE "fk_con"."confupdtype"
+          WHEN 'a' THEN 'NO ACTION'
+          WHEN 'r' THEN 'RESTRICT'
+          WHEN 'c' THEN 'CASCADE'
+          WHEN 'n' THEN 'SET NULL'
+          WHEN 'd' THEN 'SET DEFAULT'
+          ELSE NULL
+        END AS "foreign_key_on_update",
+        CASE "fk_con"."confdeltype"
+          WHEN 'a' THEN 'NO ACTION'
+          WHEN 'r' THEN 'RESTRICT'
+          WHEN 'c' THEN 'CASCADE'
+          WHEN 'n' THEN 'SET NULL'
+          WHEN 'd' THEN 'SET DEFAULT'
+          ELSE NULL
+        END AS "foreign_key_on_delete",
+
+        -- pk: true if this column is part of the table's primary key constraint
+        "pk_con"."conkey" IS NOT NULL AS "pk",
+
+        -- unique: true if the column has a single-column UNIQUE constraint OR a single-column unique index
+        (
+          -- Check for a single-column UNIQUE constraint (contype = 'u')
+          EXISTS (
+            SELECT 1
+            FROM "pg_catalog"."pg_constraint" AS "u_con"
+            WHERE "u_con"."contype" = 'u'                         -- 'u' = unique constraint
+              AND "u_con"."conrelid" = "cls"."oid"                -- on this table
+              AND array_length("u_con"."conkey", 1) = 1           -- single-column only
+              AND "att"."attnum" = ANY ("u_con"."conkey")         -- this column is in the constraint
+          )
+          OR
+          -- Check for a single-column unique index (may exist without an explicit constraint)
+          EXISTS (
+            SELECT 1
+            FROM "pg_catalog"."pg_index" AS "u_idx"
+            WHERE "u_idx"."indrelid" = "cls"."oid"                -- on this table
+              AND "u_idx"."indisunique" = TRUE                    -- it's a unique index
+              AND "u_idx"."indnkeyatts" = 1                      -- single key column
+              AND "att"."attnum" = ANY ("u_idx"."indkey"::int2[]) -- this column is the key
+          )
+        ) AS "unique",
+
+        -- unique_name: the name of the unique constraint or index (whichever exists first)
+        (
+          SELECT COALESCE(
+            -- Try constraint name first
+            (
+              SELECT "u_con"."conname"
+              FROM "pg_catalog"."pg_constraint" AS "u_con"
+              WHERE "u_con"."contype" = 'u'
+                AND "u_con"."conrelid" = "cls"."oid"
+                AND array_length("u_con"."conkey", 1) = 1
+                AND "att"."attnum" = ANY ("u_con"."conkey")
+              LIMIT 1
+            ),
+            -- Fall back to unique index name
+            (
+              SELECT "u_idx_cls"."relname"
+              FROM "pg_catalog"."pg_index" AS "u_idx"
+              JOIN "pg_catalog"."pg_class" AS "u_idx_cls" ON "u_idx"."indexrelid" = "u_idx_cls"."oid"
+              WHERE "u_idx"."indrelid" = "cls"."oid"
+                AND "u_idx"."indisunique" = TRUE
+                AND "u_idx"."indnkeyatts" = 1
+                AND "att"."attnum" = ANY ("u_idx"."indkey"::int2[])
+              LIMIT 1
+            )
+          )
+        ) AS "unique_name",
+
+        "att"."attgenerated" != '' AS "computed",  -- true if column is a generated/computed column
+        -- For generated columns, pg_attrdef stores the generation expression (not a default),
+        -- so we must null it out to avoid emitting a spurious @default(dbgenerated(...)) attribute.
+        CASE
+          WHEN "att"."attgenerated" != '' THEN NULL
+          ELSE pg_get_expr("def"."adbin", "def"."adrelid")
+        END AS "default",  -- column default expression as text (e.g., 'nextval(...)', '0', 'now()')
+        "att"."attnotnull" != TRUE AS "nullable",  -- true if column allows NULL values
+
+        -- options: for enum columns, aggregates all allowed enum labels into a JSON array
+        coalesce(
+          (
+            SELECT json_agg("enm"."enumlabel") AS "o"
+            FROM "pg_catalog"."pg_enum" AS "enm"
+            WHERE "enm"."enumtypid" = "typ"."oid"
+          ),
+          '[]'
+        ) AS "options"
+
+      -- === FROM / JOINs for the columns subquery ===
+
+      -- pg_attribute: one row per table column (attnum >= 0 excludes system columns)
+      FROM "pg_catalog"."pg_attribute" AS "att"
+
+      -- pg_type: data type of the column (e.g., int4, text, custom_enum)
+      INNER JOIN "pg_catalog"."pg_type" AS "typ" ON "typ"."oid" = "att"."atttypid"
+
+      -- pg_namespace for the type: needed to determine which schema the type lives in
+      INNER JOIN "pg_catalog"."pg_namespace" AS "tns" ON "tns"."oid" = "typ"."typnamespace"
+
+      -- information_schema.columns: provides length/precision info not easily available from pg_catalog
+      LEFT JOIN "information_schema"."columns" AS "c" ON "c"."table_schema" = "ns"."nspname"
+        AND "c"."table_name" = "cls"."relname"
+        AND "c"."column_name" = "att"."attname"
+
+      -- pg_constraint (primary key): join on contype='p' to detect if column is part of PK
+      LEFT JOIN "pg_catalog"."pg_constraint" AS "pk_con" ON "pk_con"."contype" = 'p'
+        AND "pk_con"."conrelid" = "cls"."oid"
+        AND "att"."attnum" = ANY ("pk_con"."conkey")
+
+      -- pg_constraint (foreign key): join on contype='f' to get FK details for this column
+      LEFT JOIN "pg_catalog"."pg_constraint" AS "fk_con" ON "fk_con"."contype" = 'f'
+        AND "fk_con"."conrelid" = "cls"."oid"
+        AND "att"."attnum" = ANY ("fk_con"."conkey")
+
+      -- pg_class for FK target table: resolve the referenced table's OID to its name
+      LEFT JOIN "pg_catalog"."pg_class" AS "fk_cls" ON "fk_cls"."oid" = "fk_con"."confrelid"
+
+      -- pg_namespace for FK target: get the schema of the referenced table
+      LEFT JOIN "pg_catalog"."pg_namespace" AS "fk_ns" ON "fk_ns"."oid" = "fk_cls"."relnamespace"
+
+      -- pg_attribute for FK target column: resolve the referenced column number to its name.
+      -- Use array_position to correlate by position: find this source column's index in conkey,
+      -- then pick the referenced attnum at that same index from confkey.
+      -- This ensures composite FKs correctly map each source column to its corresponding target column.
+      LEFT JOIN "pg_catalog"."pg_attribute" AS "fk_att" ON "fk_att"."attrelid" = "fk_cls"."oid"
+        AND "fk_att"."attnum" = "fk_con"."confkey"[array_position("fk_con"."conkey", "att"."attnum")]
+
+      -- pg_attrdef: column defaults; adbin contains the internal expression, decoded via pg_get_expr()
+      LEFT JOIN "pg_catalog"."pg_attrdef" AS "def" ON "def"."adrelid" = "cls"."oid" AND "def"."adnum" = "att"."attnum"
+
+      WHERE
+        "att"."attrelid" = "cls"."oid"       -- only columns belonging to this table
+        AND "att"."attnum" >= 0              -- exclude system columns (ctid, xmin, etc. have attnum < 0)
+        AND "att"."attisdropped" != TRUE     -- exclude dropped (deleted) columns
+      ORDER BY "att"."attnum"                -- preserve original column order
+    ) AS agg
+  ) AS "columns",
+
+  -- ===== INDEXES subquery =====
+  -- Aggregates all indexes for this table into a JSON array.
+  (
+    SELECT coalesce(json_agg(agg), '[]')
+    FROM (
+      SELECT
+        "idx_cls"."relname" AS "name",                          -- index name
+        "am"."amname" AS "method",                              -- access method (e.g., 'btree', 'hash', 'gin', 'gist')
+        "idx"."indisunique" AS "unique",                        -- true if unique index
+        "idx"."indisprimary" AS "primary",                      -- true if this is the PK index
+        "idx"."indisvalid" AS "valid",                          -- false during concurrent index builds
+        "idx"."indisready" AS "ready",                          -- true when index is ready for inserts
+        ("idx"."indpred" IS NOT NULL) AS "partial",             -- true if index has a WHERE clause (partial index)
+        pg_get_expr("idx"."indpred", "idx"."indrelid") AS "predicate",  -- the WHERE clause expression for partial indexes
+
+        -- Index columns: iterate over each position in the index key array
+        (
+          SELECT json_agg(
+            json_build_object(
+              -- 'name': column name, or for expression indexes the expression text
+              'name', COALESCE("att"."attname", pg_get_indexdef("idx"."indexrelid", "s"."i", true)),
+              -- 'expression': non-null only for expression-based index columns (e.g., lower(name))
+              'expression', CASE WHEN "att"."attname" IS NULL THEN pg_get_indexdef("idx"."indexrelid", "s"."i", true) ELSE NULL END,
+              -- 'order': sort direction; bit 0 of indoption = 1 means DESC
+              'order', CASE ((( "idx"."indoption"::int2[] )["s"."i"] & 1)) WHEN 1 THEN 'DESC' ELSE 'ASC' END,
+              -- 'nulls': null ordering; bit 1 of indoption = 1 means NULLS FIRST
+              'nulls', CASE (((( "idx"."indoption"::int2[] )["s"."i"] >> 1) & 1)) WHEN 1 THEN 'NULLS FIRST' ELSE 'NULLS LAST' END
+            )
+            ORDER BY "s"."i"  -- preserve column order within the index
+          )
+          -- generate_subscripts creates one row per index key position (1-based)
+          FROM generate_subscripts("idx"."indkey"::int2[], 1) AS "s"("i")
+          -- Join to pg_attribute to resolve column numbers to names
+          -- NULL attname means it's an expression index column
+          LEFT JOIN "pg_catalog"."pg_attribute" AS "att"
+            ON "att"."attrelid" = "cls"."oid"
+           AND "att"."attnum" = ("idx"."indkey"::int2[])["s"."i"]
+        ) AS "columns"
+
+      FROM "pg_catalog"."pg_index" AS "idx"                     -- pg_index: one row per index
+      JOIN "pg_catalog"."pg_class" AS "idx_cls" ON "idx"."indexrelid" = "idx_cls"."oid"  -- index's own pg_class entry (for the name)
+      JOIN "pg_catalog"."pg_am" AS "am" ON "idx_cls"."relam" = "am"."oid"                -- access method catalog
+      WHERE "idx"."indrelid" = "cls"."oid"                      -- only indexes on this table
+      ORDER BY "idx_cls"."relname"
+    ) AS agg
+  ) AS "indexes"
+
+-- === Main FROM: pg_class (tables and views) joined with pg_namespace (schemas) ===
+FROM "pg_catalog"."pg_class" AS "cls"
+INNER JOIN "pg_catalog"."pg_namespace" AS "ns" ON "cls"."relnamespace" = "ns"."oid"
+WHERE
+  "ns"."nspname" !~ '^pg_'                   -- exclude PostgreSQL internal schemas (pg_catalog, pg_toast, etc.)
+  AND "ns"."nspname" != 'information_schema'  -- exclude the information_schema
+  AND "cls"."relkind" IN ('r', 'v')           -- only tables ('r') and views ('v')
+  AND "cls"."relname" !~ '^pg_'               -- exclude system tables starting with pg_
+  AND "cls"."relname" !~ '_prisma_migrations' -- exclude Prisma migration tracking table
+  ORDER BY "ns"."nspname", "cls"."relname" ASC;
+`;
+function typeCastingConvert({ defaultValue, enums, val, services }) {
+	const [value, type] = val.replace(/'/g, "").split("::").map((s) => s.trim());
+	switch (type) {
+		case "character varying":
+		case "uuid":
+		case "json":
+		case "jsonb":
+		case "text":
+			if (value === "NULL") return null;
+			return (ab) => ab.StringLiteral.setValue(value);
+		case "real": return (ab) => ab.NumberLiteral.setValue(value);
+		default: {
+			const enumDef = enums.find((e) => getDbName(e, true) === type);
+			if (!enumDef) return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("dbgenerated", services)).addArg((a) => a.setValue((v) => v.StringLiteral.setValue(val)));
+			const enumField = enumDef.fields.find((v) => getDbName(v) === value);
+			if (!enumField) throw new CliError(`Enum value ${value} not found in enum ${type} for default value ${defaultValue}`);
+			return (ab) => ab.ReferenceExpr.setTarget(enumField);
+		}
+	}
+}
+//#endregion
+//#region src/actions/pull/provider/sqlite.ts
+const sqlite = {
+	isSupportedFeature(feature) {
+		switch (feature) {
+			case "Schema": return false;
+			case "NativeEnum": return false;
+			default: return false;
+		}
+	},
+	getBuiltinType(type) {
+		const t = (type || "").toLowerCase().trim().replace(/\(.*\)$/, "").trim();
+		const isArray = false;
+		switch (t) {
+			case "integer":
+			case "int":
+			case "tinyint":
+			case "smallint":
+			case "mediumint":
+			case "int2":
+			case "int8": return {
+				type: "Int",
+				isArray
+			};
+			case "bigint":
+			case "unsigned big int": return {
+				type: "BigInt",
+				isArray
+			};
+			case "text":
+			case "varchar":
+			case "char":
+			case "character":
+			case "varying character":
+			case "nchar":
+			case "native character":
+			case "nvarchar":
+			case "clob": return {
+				type: "String",
+				isArray
+			};
+			case "blob": return {
+				type: "Bytes",
+				isArray
+			};
+			case "real":
+			case "float":
+			case "double":
+			case "double precision": return {
+				type: "Float",
+				isArray
+			};
+			case "numeric":
+			case "decimal": return {
+				type: "Decimal",
+				isArray
+			};
+			case "datetime":
+			case "date":
+			case "time":
+			case "timestamp": return {
+				type: "DateTime",
+				isArray
+			};
+			case "json":
+			case "jsonb": return {
+				type: "Json",
+				isArray
+			};
+			case "boolean":
+			case "bool": return {
+				type: "Boolean",
+				isArray
+			};
+			default:
+				if (!t) return {
+					type: "Bytes",
+					isArray
+				};
+				if (t.includes("int")) return {
+					type: "Int",
+					isArray
+				};
+				if (t.includes("char") || t.includes("clob") || t.includes("text")) return {
+					type: "String",
+					isArray
+				};
+				if (t.includes("blob")) return {
+					type: "Bytes",
+					isArray
+				};
+				if (t.includes("real") || t.includes("floa") || t.includes("doub")) return {
+					type: "Float",
+					isArray
+				};
+				return {
+					type: "Unsupported",
+					isArray
+				};
+		}
+	},
+	getDefaultDatabaseType() {},
+	async introspect(connectionString, _options) {
+		const SQLite = (await import("better-sqlite3")).default;
+		const db = new SQLite(connectionString, { readonly: true });
+		try {
+			const all = (sql) => {
+				return db.prepare(sql).all();
+			};
+			const tablesRaw = all("SELECT name, type, sql AS definition FROM sqlite_schema WHERE type IN ('table','view') AND name NOT LIKE 'sqlite_%' AND name <> '_prisma_migrations' ORDER BY name");
+			const autoIncrementTables = /* @__PURE__ */ new Set();
+			for (const t of tablesRaw) if (t.type === "table" && t.definition) {
+				if (/\bAUTOINCREMENT\b/i.test(t.definition)) autoIncrementTables.add(t.name);
+			}
+			const tables = [];
+			for (const t of tablesRaw) {
+				const tableName = t.name;
+				const schema = "";
+				const hasAutoIncrement = autoIncrementTables.has(tableName);
+				const columnsInfo = all(`PRAGMA table_xinfo('${tableName.replace(/'/g, "''")}')`);
+				const idxList = all(`PRAGMA index_list('${tableName.replace(/'/g, "''")}')`).filter((r) => !r.name.startsWith("sqlite_autoindex_"));
+				const uniqueSingleColumn = /* @__PURE__ */ new Set();
+				const uniqueIndexRows = idxList.filter((r) => r.unique === 1 && r.partial !== 1);
+				for (const idx of uniqueIndexRows) {
+					const idxCols = all(`PRAGMA index_info('${idx.name.replace(/'/g, "''")}')`);
+					if (idxCols.length === 1 && idxCols[0]?.name) uniqueSingleColumn.add(idxCols[0].name);
+				}
+				const indexes = idxList.map((idx) => {
+					const idxCols = all(`PRAGMA index_info('${idx.name.replace(/'/g, "''")}')`);
+					return {
+						name: idx.name,
+						method: null,
+						unique: idx.unique === 1,
+						primary: false,
+						valid: true,
+						ready: true,
+						partial: idx.partial === 1,
+						predicate: idx.partial === 1 ? "[partial]" : null,
+						columns: idxCols.map((col) => ({
+							name: col.name,
+							expression: null,
+							order: null,
+							nulls: null
+						}))
+					};
+				});
+				const fkRows = all(`PRAGMA foreign_key_list('${tableName.replace(/'/g, "''")}')`);
+				const fkConstraintNames = /* @__PURE__ */ new Map();
+				if (t.definition) {
+					const fkRegex = /CONSTRAINT\s+(?:["'`]([^"'`]+)["'`]|(\w+))\s+FOREIGN\s+KEY\s*\(([^)]+)\)/gi;
+					let match;
+					while ((match = fkRegex.exec(t.definition)) !== null) {
+						const constraintName = match[1] || match[2];
+						const columnList = match[3];
+						if (constraintName && columnList) {
+							const columns = columnList.split(",").map((col) => col.trim().replace(/^["'`]|["'`]$/g, ""));
+							for (const col of columns) if (col) fkConstraintNames.set(col, constraintName);
+						}
+					}
+				}
+				const fkByColumn = /* @__PURE__ */ new Map();
+				for (const fk of fkRows) fkByColumn.set(fk.from, {
+					foreign_key_schema: "",
+					foreign_key_table: fk.table || null,
+					foreign_key_column: fk.to || null,
+					foreign_key_name: fkConstraintNames.get(fk.from) ?? null,
+					foreign_key_on_update: fk.on_update ?? null,
+					foreign_key_on_delete: fk.on_delete ?? null
+				});
+				const generatedColDefs = t.definition ? extractColumnTypeDefs(t.definition) : /* @__PURE__ */ new Map();
+				const columns = [];
+				for (const c of columnsInfo) {
+					const hidden = c.hidden ?? 0;
+					if (hidden === 1) continue;
+					const isGenerated = hidden === 2 || hidden === 3;
+					const fk = fkByColumn.get(c.name);
+					let defaultValue = c.dflt_value;
+					if (hasAutoIncrement && c.pk) defaultValue = "autoincrement";
+					let datatype = c.type || "";
+					if (isGenerated) {
+						const fullDef = generatedColDefs.get(c.name);
+						if (fullDef) datatype = fullDef;
+					}
+					columns.push({
+						name: c.name,
+						datatype,
+						datatype_name: null,
+						length: null,
+						precision: null,
+						datatype_schema: schema,
+						foreign_key_schema: fk?.foreign_key_schema ?? null,
+						foreign_key_table: fk?.foreign_key_table ?? null,
+						foreign_key_column: fk?.foreign_key_column ?? null,
+						foreign_key_name: fk?.foreign_key_name ?? null,
+						foreign_key_on_update: fk?.foreign_key_on_update ?? null,
+						foreign_key_on_delete: fk?.foreign_key_on_delete ?? null,
+						pk: !!c.pk,
+						computed: isGenerated,
+						nullable: c.notnull !== 1,
+						default: defaultValue,
+						unique: uniqueSingleColumn.has(c.name),
+						unique_name: null
+					});
+				}
+				tables.push({
+					schema,
+					name: tableName,
+					columns,
+					type: t.type,
+					definition: t.definition,
+					indexes
+				});
+			}
+			return {
+				tables,
+				enums: []
+			};
+		} finally {
+			db.close();
+		}
+	},
+	getDefaultValue({ defaultValue, fieldType, services, enums }) {
+		const val = defaultValue.trim();
+		switch (fieldType) {
+			case "DateTime":
+				if (val === "CURRENT_TIMESTAMP" || val === "now()") return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("now", services));
+				return (ab) => ab.StringLiteral.setValue(val);
+			case "Int":
+			case "BigInt":
+				if (val === "autoincrement") return (ab) => ab.InvocationExpr.setFunction(getFunctionRef("autoincrement", services));
+				return (ab) => ab.NumberLiteral.setValue(val);
+			case "Float": return normalizeFloatDefault(val);
+			case "Decimal": return normalizeDecimalDefault(val);
+			case "Boolean": return (ab) => ab.BooleanLiteral.setValue(val === "true" || val === "1");
+			case "String":
+				if (val.startsWith("'") && val.endsWith("'")) {
+					const strippedName = val.slice(1, -1);
+					const enumDef = enums.find((e) => e.fields.find((v) => getDbName(v) === strippedName));
+					if (enumDef) {
+						const enumField = enumDef.fields.find((v) => getDbName(v) === strippedName);
+						if (enumField) return (ab) => ab.ReferenceExpr.setTarget(enumField);
+					}
+					return (ab) => ab.StringLiteral.setValue(strippedName);
+				}
+				return (ab) => ab.StringLiteral.setValue(val);
+			case "Json": return (ab) => ab.StringLiteral.setValue(val);
+			case "Bytes": return (ab) => ab.StringLiteral.setValue(val);
+		}
+		console.warn(`Unsupported default value type: "${defaultValue}" for field type "${fieldType}". Skipping default value.`);
+		return null;
+	},
+	getFieldAttributes({ fieldName, fieldType, services }) {
+		const factories = [];
+		if (fieldType === "DateTime" && (fieldName.toLowerCase() === "updatedat" || fieldName.toLowerCase() === "updated_at")) factories.push(new DataFieldAttributeFactory().setDecl(getAttributeRef("@updatedAt", services)));
+		return factories;
+	}
+};
+/**
+* Extract column type definitions from a CREATE TABLE DDL statement.
+* Returns a map of column name → full type definition string (everything after the column name).
+* Used to get the complete type including GENERATED ALWAYS AS (...) STORED/VIRTUAL for generated columns.
+*/
+function extractColumnTypeDefs(ddl) {
+	const openIdx = ddl.indexOf("(");
+	if (openIdx === -1) return /* @__PURE__ */ new Map();
+	let depth = 1;
+	let closeIdx = -1;
+	for (let i = openIdx + 1; i < ddl.length; i++) if (ddl[i] === "(") depth++;
+	else if (ddl[i] === ")") {
+		depth--;
+		if (depth === 0) {
+			closeIdx = i;
+			break;
+		}
+	}
+	if (closeIdx === -1) return /* @__PURE__ */ new Map();
+	const content = ddl.substring(openIdx + 1, closeIdx);
+	const defs = [];
+	let current = "";
+	depth = 0;
+	for (const char of content) {
+		if (char === "(") depth++;
+		else if (char === ")") depth--;
+		else if (char === "," && depth === 0) {
+			defs.push(current.trim());
+			current = "";
+			continue;
+		}
+		current += char;
+	}
+	if (current.trim()) defs.push(current.trim());
+	const result = /* @__PURE__ */ new Map();
+	for (const def of defs) {
+		const nameMatch = def.match(/^(?:["'`]([^"'`]+)["'`]|(\w+))\s+(.+)/s);
+		if (nameMatch) {
+			const name = nameMatch[1] || nameMatch[2];
+			const typeDef = nameMatch[3];
+			if (name && typeDef) result.set(name, typeDef.trim());
+		}
+	}
+	return result;
+}
+//#endregion
+//#region src/actions/pull/provider/index.ts
+const providers = {
+	mysql,
+	postgresql,
+	sqlite
+};
+//#endregion
+//#region src/actions/db.ts
+/**
+* CLI action for db related commands
+*/
+async function run$7(command, options) {
+	switch (command) {
+		case "push":
+			await runPush(options);
+			break;
+		case "pull":
+			await runPull(options);
+			break;
+	}
+}
+async function runPush(options) {
+	const schemaFile = getSchemaFile(options.schema);
+	await requireDataSourceUrl(schemaFile);
+	const prismaSchemaFile = await generateTempPrismaSchema(schemaFile);
+	try {
+		const cmd = [
+			"db push",
+			` --schema "${prismaSchemaFile}"`,
+			options.acceptDataLoss ? " --accept-data-loss" : "",
+			options.forceReset ? " --force-reset" : "",
+			" --skip-generate"
+		].join("");
+		try {
+			execPrisma(cmd);
+		} catch (err) {
+			handleSubProcessError$1(err);
+		}
+	} finally {
+		if (fs.existsSync(prismaSchemaFile)) fs.unlinkSync(prismaSchemaFile);
+	}
+}
+async function runPull(options) {
+	const spinner = ora();
+	try {
+		const schemaFile = getSchemaFile(options.schema);
+		const outPath = options.output ? path.resolve(options.output) : void 0;
+		const treatAsFile = !!outPath && (fs.existsSync(outPath) && fs.lstatSync(outPath).isFile() || path.extname(outPath) !== "");
+		const { model, services } = await loadSchemaDocument(schemaFile, {
+			returnServices: true,
+			mergeImports: treatAsFile
+		});
+		const SUPPORTED_PROVIDERS = Object.keys(providers);
+		const datasource = getDatasource(model);
+		if (!SUPPORTED_PROVIDERS.includes(datasource.provider)) throw new CliError(`Unsupported datasource provider: ${datasource.provider}`);
+		const provider = providers[datasource.provider];
+		if (!provider) throw new CliError(`No introspection provider found for: ${datasource.provider}`);
+		spinner.start("Introspecting database...");
+		const { enums, tables } = await provider.introspect(datasource.url, {
+			schemas: datasource.allSchemas,
+			modelCasing: options.modelCasing
+		});
+		spinner.succeed("Database introspected");
+		console.log(colors.blue("Syncing schema..."));
+		const newModel = {
+			$type: "Model",
+			$container: void 0,
+			$containerProperty: void 0,
+			$containerIndex: void 0,
+			declarations: [...model.declarations.filter((d) => ["DataSource"].includes(d.$type))],
+			imports: model.imports
+		};
+		syncEnums({
+			dbEnums: enums,
+			model: newModel,
+			services,
+			options,
+			defaultSchema: datasource.defaultSchema,
+			oldModel: model,
+			provider
+		});
+		const resolvedRelations = [];
+		for (const table of tables) {
+			const relations = syncTable({
+				table,
+				model: newModel,
+				provider,
+				services,
+				options,
+				defaultSchema: datasource.defaultSchema,
+				oldModel: model
+			});
+			resolvedRelations.push(...relations);
+		}
+		for (const relation of resolvedRelations) {
+			const similarRelations = resolvedRelations.filter((rr) => {
+				return rr !== relation && (rr.schema === relation.schema && rr.table === relation.table && rr.references.schema === relation.references.schema && rr.references.table === relation.references.table || rr.schema === relation.references.schema && rr.columns[0] === relation.references.columns[0] && rr.references.schema === relation.schema && rr.references.table === relation.table);
+			}).length;
+			syncRelation({
+				model: newModel,
+				relation,
+				services,
+				options,
+				selfRelation: relation.references.schema === relation.schema && relation.references.table === relation.table,
+				similarRelations
+			});
+		}
+		consolidateEnums({
+			newModel,
+			oldModel: model
+		});
+		console.log(colors.blue("Schema synced"));
+		const baseDir = path.dirname(path.resolve(schemaFile));
+		const baseDirUrlPath = new URL(`file://${baseDir}`).pathname;
+		const docs = services.shared.workspace.LangiumDocuments.all.filter(({ uri }) => uri.path.toLowerCase().startsWith(baseDirUrlPath.toLowerCase())).toArray();
+		const docsSet = new Set(docs.map((d) => d.uri.toString()));
+		console.log(colors.bold("\nApplying changes to ZModel..."));
+		const deletedModels = [];
+		const deletedEnums = [];
+		const addedModels = [];
+		const addedEnums = [];
+		const modelChanges = /* @__PURE__ */ new Map();
+		const getModelChanges = (modelName) => {
+			if (!modelChanges.has(modelName)) modelChanges.set(modelName, {
+				addedFields: [],
+				deletedFields: [],
+				updatedFields: [],
+				addedAttributes: [],
+				deletedAttributes: [],
+				updatedAttributes: []
+			});
+			return modelChanges.get(modelName);
+		};
+		services.shared.workspace.IndexManager.allElements("DataModel", docsSet).filter((declaration) => !newModel.declarations.find((d) => getDbName(d) === getDbName(declaration.node))).forEach((decl) => {
+			const model = decl.node.$container;
+			const index = model.declarations.findIndex((d) => d === decl.node);
+			model.declarations.splice(index, 1);
+			deletedModels.push(colors.red(`- Model ${decl.name} deleted`));
+		});
+		if (provider.isSupportedFeature("NativeEnum")) services.shared.workspace.IndexManager.allElements("Enum", docsSet).filter((declaration) => !newModel.declarations.find((d) => getDbName(d) === getDbName(declaration.node))).forEach((decl) => {
+			const model = decl.node.$container;
+			const index = model.declarations.findIndex((d) => d === decl.node);
+			model.declarations.splice(index, 1);
+			deletedEnums.push(colors.red(`- Enum ${decl.name} deleted`));
+		});
+		newModel.declarations.filter((d) => [DataModel, Enum].includes(d.$type)).forEach((_declaration) => {
+			const newDataModel = _declaration;
+			const declarations = services.shared.workspace.IndexManager.allElements(newDataModel.$type, docsSet).toArray();
+			const originalDataModel = declarations.find((d) => getDbName(d.node) === getDbName(newDataModel))?.node;
+			if (!originalDataModel) {
+				if (newDataModel.$type === "DataModel") addedModels.push(colors.green(`+ Model ${newDataModel.name} added`));
+				else if (newDataModel.$type === "Enum") addedEnums.push(colors.green(`+ Enum ${newDataModel.name} added`));
+				model.declarations.push(newDataModel);
+				newDataModel.$container = model;
+				newDataModel.fields.forEach((f) => {
+					if (f.$type === "DataField" && f.type.reference?.ref) {
+						const ref = declarations.find((d) => getDbName(d.node) === getDbName(f.type.reference.ref))?.node;
+						if (ref && f.type.reference) f.type.reference = {
+							ref,
+							$refText: ref.name ?? f.type.reference.$refText
+						};
+					}
+				});
+				return;
+			}
+			newDataModel.fields.forEach((f) => {
+				let originalFields = originalDataModel.fields.filter((d) => getDbName(d) === getDbName(f));
+				const isRelationField = f.$type === "DataField" && !!f.attributes?.some((a) => a?.decl?.ref?.name === "@relation");
+				if (originalFields.length === 0 && isRelationField && !getRelationFieldsKey(f)) return;
+				if (originalFields.length === 0) {
+					const newFieldsKey = getRelationFieldsKey(f);
+					if (newFieldsKey) originalFields = originalDataModel.fields.filter((d) => getRelationFieldsKey(d) === newFieldsKey);
+				}
+				if (originalFields.length === 0) originalFields = originalDataModel.fields.filter((d) => getRelationFkName(d) === getRelationFkName(f) && !!getRelationFkName(d) && !!getRelationFkName(f));
+				if (originalFields.length === 0) originalFields = originalDataModel.fields.filter((d) => f.$type === "DataField" && d.$type === "DataField" && f.type.reference?.ref && d.type.reference?.ref && getDbName(f.type.reference.ref) === getDbName(d.type.reference.ref));
+				if (originalFields.length > 1) {
+					if (!!getRelationFieldsKey(f)) console.warn(colors.yellow(`Found more original fields, need to tweak the search algorithm. ${originalDataModel.name}->[${originalFields.map((of) => of.name).join(", ")}](${f.name})`));
+					return;
+				}
+				const originalField = originalFields.at(0);
+				if (originalField && f.$type === "DataField" && originalField.$type === "DataField") {
+					const newType = f.type;
+					const oldType = originalField.type;
+					const fieldUpdates = [];
+					const isOldTypeEnumWithoutNativeSupport = oldType.reference?.ref?.$type === "Enum" && !provider.isSupportedFeature("NativeEnum");
+					if (newType.type && oldType.type !== newType.type && !isOldTypeEnumWithoutNativeSupport) {
+						fieldUpdates.push(`type: ${oldType.type} -> ${newType.type}`);
+						oldType.type = newType.type;
+					}
+					if (newType.reference?.ref && oldType.reference?.ref) {
+						if (getDbName(newType.reference.ref) !== getDbName(oldType.reference.ref)) {
+							fieldUpdates.push(`reference: ${oldType.reference.$refText} -> ${newType.reference.$refText}`);
+							oldType.reference = {
+								ref: newType.reference.ref,
+								$refText: newType.reference.$refText
+							};
+						}
+					} else if (newType.reference?.ref && !oldType.reference) {
+						fieldUpdates.push(`type: ${oldType.type} -> ${newType.reference.$refText}`);
+						oldType.reference = newType.reference;
+						oldType.type = void 0;
+					} else if (!newType.reference && oldType.reference?.ref && newType.type) {
+						if (!(oldType.reference.ref.$type === "Enum" && !provider.isSupportedFeature("NativeEnum"))) {
+							fieldUpdates.push(`type: ${oldType.reference.$refText} -> ${newType.type}`);
+							oldType.type = newType.type;
+							oldType.reference = void 0;
+						}
+					}
+					if (!!newType.optional !== !!oldType.optional) {
+						fieldUpdates.push(`optional: ${!!oldType.optional} -> ${!!newType.optional}`);
+						oldType.optional = newType.optional;
+					}
+					if (!!newType.array !== !!oldType.array) {
+						fieldUpdates.push(`array: ${!!oldType.array} -> ${!!newType.array}`);
+						oldType.array = newType.array;
+					}
+					if (fieldUpdates.length > 0) getModelChanges(originalDataModel.name).updatedFields.push(colors.yellow(`~ ${originalField.name} (${fieldUpdates.join(", ")})`));
+					const newDefaultAttr = f.attributes.find((a) => a.decl.$refText === "@default");
+					const oldDefaultAttr = originalField.attributes.find((a) => a.decl.$refText === "@default");
+					if (newDefaultAttr && oldDefaultAttr) {
+						const serializeArgs = (args) => args.map((arg) => {
+							if (arg.value?.$type === "StringLiteral") return `"${arg.value.value}"`;
+							if (arg.value?.$type === "NumberLiteral") return String(arg.value.value);
+							if (arg.value?.$type === "BooleanLiteral") return String(arg.value.value);
+							if (arg.value?.$type === "InvocationExpr") return arg.value.function?.$refText ?? "";
+							if (arg.value?.$type === "ReferenceExpr") return arg.value.target?.$refText ?? "";
+							if (arg.value?.$type === "ArrayExpr") return `[${(arg.value.items ?? []).map((item) => {
+								if (item.$type === "ReferenceExpr") return item.target?.$refText ?? "";
+								return item.$type ?? "unknown";
+							}).join(",")}]`;
+							return arg.value?.$type ?? "unknown";
+						}).join(",");
+						if (serializeArgs(newDefaultAttr.args ?? []) !== serializeArgs(oldDefaultAttr.args ?? [])) {
+							oldDefaultAttr.args = newDefaultAttr.args.map((arg) => ({
+								...arg,
+								$container: oldDefaultAttr
+							}));
+							getModelChanges(originalDataModel.name).updatedAttributes.push(colors.yellow(`~ @default on ${originalDataModel.name}.${originalField.name}`));
+						}
+					}
+				}
+				if (!originalField) {
+					getModelChanges(originalDataModel.name).addedFields.push(colors.green(`+ ${f.name}`));
+					f.$container = originalDataModel;
+					originalDataModel.fields.push(f);
+					if (f.$type === "DataField" && f.type.reference?.ref) {
+						const ref = declarations.find((d) => getDbName(d.node) === getDbName(f.type.reference.ref))?.node;
+						if (ref) f.type.reference = {
+							ref,
+							$refText: ref.name ?? f.type.reference.$refText
+						};
+					}
+					return;
+				}
+				originalField.attributes.filter((attr) => !f.attributes.find((d) => d.decl.$refText === attr.decl.$refText) && isDatabaseManagedAttribute(attr.decl.$refText)).forEach((attr) => {
+					const field = attr.$container;
+					const index = field.attributes.findIndex((d) => d === attr);
+					field.attributes.splice(index, 1);
+					getModelChanges(originalDataModel.name).deletedAttributes.push(colors.yellow(`- ${attr.decl.$refText} from field: ${originalDataModel.name}.${field.name}`));
+				});
+				f.attributes.filter((attr) => !originalField.attributes.find((d) => d.decl.$refText === attr.decl.$refText) && isDatabaseManagedAttribute(attr.decl.$refText)).forEach((attr) => {
+					const cloned = {
+						...attr,
+						$container: originalField
+					};
+					originalField.attributes.push(cloned);
+					getModelChanges(originalDataModel.name).addedAttributes.push(colors.green(`+ ${attr.decl.$refText} to field: ${originalDataModel.name}.${f.name}`));
+				});
+			});
+			originalDataModel.fields.filter((f) => {
+				if (newDataModel.fields.find((d) => getDbName(d) === getDbName(f))) return false;
+				const originalFieldsKey = getRelationFieldsKey(f);
+				if (originalFieldsKey) {
+					if (newDataModel.fields.find((d) => getRelationFieldsKey(d) === originalFieldsKey)) return false;
+				}
+				if (newDataModel.fields.find((d) => getRelationFkName(d) === getRelationFkName(f) && !!getRelationFkName(d) && !!getRelationFkName(f))) return false;
+				return !newDataModel.fields.find((d) => f.$type === "DataField" && d.$type === "DataField" && f.type.reference?.ref && d.type.reference?.ref && getDbName(f.type.reference.ref) === getDbName(d.type.reference.ref));
+			}).forEach((f) => {
+				const _model = f.$container;
+				const index = _model.fields.findIndex((d) => d === f);
+				_model.fields.splice(index, 1);
+				getModelChanges(_model.name).deletedFields.push(colors.red(`- ${f.name}`));
+			});
+		});
+		if (deletedModels.length > 0) {
+			console.log(colors.bold("\nDeleted Models:"));
+			deletedModels.forEach((msg) => {
+				console.log(msg);
+			});
+		}
+		if (deletedEnums.length > 0) {
+			console.log(colors.bold("\nDeleted Enums:"));
+			deletedEnums.forEach((msg) => {
+				console.log(msg);
+			});
+		}
+		if (addedModels.length > 0) {
+			console.log(colors.bold("\nAdded Models:"));
+			addedModels.forEach((msg) => {
+				console.log(msg);
+			});
+		}
+		if (addedEnums.length > 0) {
+			console.log(colors.bold("\nAdded Enums:"));
+			addedEnums.forEach((msg) => {
+				console.log(msg);
+			});
+		}
+		if (modelChanges.size > 0) {
+			console.log(colors.bold("\nModel Changes:"));
+			modelChanges.forEach((changes, modelName) => {
+				if (changes.addedFields.length > 0 || changes.deletedFields.length > 0 || changes.updatedFields.length > 0 || changes.addedAttributes.length > 0 || changes.deletedAttributes.length > 0 || changes.updatedAttributes.length > 0) {
+					console.log(colors.cyan(`  ${modelName}:`));
+					if (changes.addedFields.length > 0) {
+						console.log(colors.gray("    Added Fields:"));
+						changes.addedFields.forEach((msg) => {
+							console.log(`      ${msg}`);
+						});
+					}
+					if (changes.deletedFields.length > 0) {
+						console.log(colors.gray("    Deleted Fields:"));
+						changes.deletedFields.forEach((msg) => {
+							console.log(`      ${msg}`);
+						});
+					}
+					if (changes.updatedFields.length > 0) {
+						console.log(colors.gray("    Updated Fields:"));
+						changes.updatedFields.forEach((msg) => {
+							console.log(`      ${msg}`);
+						});
+					}
+					if (changes.addedAttributes.length > 0) {
+						console.log(colors.gray("    Added Attributes:"));
+						changes.addedAttributes.forEach((msg) => {
+							console.log(`      ${msg}`);
+						});
+					}
+					if (changes.deletedAttributes.length > 0) {
+						console.log(colors.gray("    Deleted Attributes:"));
+						changes.deletedAttributes.forEach((msg) => {
+							console.log(`      ${msg}`);
+						});
+					}
+					if (changes.updatedAttributes.length > 0) {
+						console.log(colors.gray("    Updated Attributes:"));
+						changes.updatedAttributes.forEach((msg) => {
+							console.log(`      ${msg}`);
+						});
+					}
+				}
+			});
+		}
+		const generator = new ZModelCodeGenerator({
+			quote: options.quote ?? "single",
+			indent: options.indent ?? 4
+		});
+		if (options.output) if (treatAsFile) {
+			const zmodelSchema = await formatDocument(generator.generate(newModel));
+			console.log(colors.blue(`Writing to ${outPath}`));
+			fs.mkdirSync(path.dirname(outPath), { recursive: true });
+			fs.writeFileSync(outPath, zmodelSchema);
+		} else {
+			fs.mkdirSync(outPath, { recursive: true });
+			const baseDir = path.dirname(path.resolve(schemaFile));
+			for (const { uri, parseResult: { value: documentModel } } of docs) {
+				const zmodelSchema = await formatDocument(generator.generate(documentModel));
+				const relPath = path.relative(baseDir, uri.fsPath);
+				const targetFile = path.join(outPath, relPath);
+				fs.mkdirSync(path.dirname(targetFile), { recursive: true });
+				console.log(colors.blue(`Writing to ${targetFile}`));
+				fs.writeFileSync(targetFile, zmodelSchema);
+			}
+		}
+		else for (const { uri, parseResult: { value: documentModel } } of docs) {
+			const zmodelSchema = await formatDocument(generator.generate(documentModel));
+			console.log(colors.blue(`Writing to ${path.relative(process.cwd(), uri.fsPath).replace(/\\/g, "/")}`));
+			fs.writeFileSync(uri.fsPath, zmodelSchema);
+		}
+		console.log(colors.green.bold("\nPull completed successfully!"));
+	} catch (error) {
+		spinner.fail("Pull failed");
+		console.error(error);
+		throw error;
+	}
+}
+//#endregion
+//#region src/actions/format.ts
+/**
+* CLI action for formatting a ZModel schema file.
+*/
+async function run$6(options) {
+	const schemaFile = getSchemaFile(options.schema);
+	let formattedContent;
+	try {
+		formattedContent = await formatDocument(fs.readFileSync(schemaFile, "utf-8"));
+	} catch (error) {
+		console.error(colors.red("✗ Schema formatting failed."));
+		throw error;
+	}
+	fs.writeFileSync(schemaFile, formattedContent, "utf-8");
+	console.log(colors.green("✓ Schema formatting completed successfully."));
+}
+//#endregion
+//#region src/plugins/prisma.ts
+const plugin$1 = {
+	name: "Prisma Schema Generator",
+	statusText: "Generating Prisma schema",
+	async generate({ model, defaultOutputPath, pluginOptions }) {
+		let outFile = path.join(defaultOutputPath, "schema.prisma");
+		if (typeof pluginOptions["output"] === "string") {
+			outFile = path.resolve(defaultOutputPath, pluginOptions["output"]);
+			if (!fs.existsSync(path.dirname(outFile))) fs.mkdirSync(path.dirname(outFile), { recursive: true });
+		}
+		const prismaSchema = await new PrismaSchemaGenerator(model).generate();
+		fs.writeFileSync(outFile, prismaSchema);
+	}
+};
+//#endregion
+//#region src/plugins/typescript.ts
+const plugin = {
+	name: "TypeScript Schema Generator",
+	statusText: "Generating TypeScript schema",
+	async generate({ model, defaultOutputPath, pluginOptions }) {
+		let outDir = defaultOutputPath;
+		if (typeof pluginOptions["output"] === "string") {
+			outDir = path.resolve(defaultOutputPath, pluginOptions["output"]);
+			if (!fs.existsSync(outDir)) fs.mkdirSync(outDir, { recursive: true });
+		}
+		const lite = pluginOptions["lite"] === true;
+		const liteOnly = pluginOptions["liteOnly"] === true;
+		const importWithFileExtension = pluginOptions["importWithFileExtension"];
+		if (importWithFileExtension && typeof importWithFileExtension !== "string") throw new Error("The \"importWithFileExtension\" option must be a string if specified.");
+		const generateModelTypes = pluginOptions["generateModels"] !== false;
+		const generateInputTypes = pluginOptions["generateInput"] !== false;
+		await new TsSchemaGenerator().generate(model, {
+			outDir,
+			lite,
+			liteOnly,
+			importWithFileExtension,
+			generateModelTypes,
+			generateInputTypes
+		});
+	}
+};
+//#endregion
+//#region src/plugins/index.ts
+var plugins_exports = /* @__PURE__ */ __exportAll({
+	prisma: () => plugin$1,
+	typescript: () => plugin
+});
+//#endregion
+//#region src/actions/generate.ts
+/**
+* CLI action for generating code from schema
+*/
+async function run$5(options) {
+	try {
+		await checkForMismatchedPackages(process.cwd());
+	} catch (err) {
+		console.warn(colors.yellow(`Failed to check for mismatched ZenStack packages: ${err}`));
+	}
+	const maybeShowUsageTips = options.tips && !options.silent && !options.watch ? startUsageTipsFetch() : void 0;
+	const model = await pureGenerate(options, false);
+	await maybeShowUsageTips?.();
+	if (options.watch) {
+		const logsEnabled = !options.silent;
+		if (logsEnabled) console.log(colors.green(`\nEnabled watch mode!`));
+		const schemaExtensions = ZModelLanguageMetaData.fileExtensions;
+		const getRootModelWatchPaths = (model) => new Set(model.declarations.filter((v) => v.$cstNode?.parent?.element.$type === "Model" && !!v.$cstNode.parent.element.$document?.uri?.fsPath).map((v) => v.$cstNode.parent.element.$document.uri.fsPath));
+		const watchedPaths = getRootModelWatchPaths(model);
+		if (logsEnabled) {
+			const logPaths = [...watchedPaths].map((at) => `- ${at}`).join("\n");
+			console.log(`Watched file paths:\n${logPaths}`);
+		}
+		const watcher = watch([...watchedPaths], {
+			alwaysStat: false,
+			ignoreInitial: true,
+			ignorePermissionErrors: true,
+			ignored: (at) => !schemaExtensions.some((ext) => at.endsWith(ext))
+		});
+		const reGenerateSchema = singleDebounce(async () => {
+			if (logsEnabled) console.log("Got changes, run generation!");
+			try {
+				const allModelsPaths = getRootModelWatchPaths(await pureGenerate(options, true));
+				const newModelPaths = [...allModelsPaths].filter((at) => !watchedPaths.has(at));
+				const removeModelPaths = [...watchedPaths].filter((at) => !allModelsPaths.has(at));
+				if (newModelPaths.length) {
+					if (logsEnabled) {
+						const logPaths = newModelPaths.map((at) => `- ${at}`).join("\n");
+						console.log(`Added file(s) to watch:\n${logPaths}`);
+					}
+					newModelPaths.forEach((at) => watchedPaths.add(at));
+					watcher.add(newModelPaths);
+				}
+				if (removeModelPaths.length) {
+					if (logsEnabled) {
+						const logPaths = removeModelPaths.map((at) => `- ${at}`).join("\n");
+						console.log(`Removed file(s) from watch:\n${logPaths}`);
+					}
+					removeModelPaths.forEach((at) => watchedPaths.delete(at));
+					watcher.unwatch(removeModelPaths);
+				}
+			} catch (e) {
+				console.error(e);
+			}
+		}, 500, true);
+		watcher.on("unlink", (pathAt) => {
+			if (logsEnabled) console.log(`Removed file from watch: ${pathAt}`);
+			watchedPaths.delete(pathAt);
+			watcher.unwatch(pathAt);
+			reGenerateSchema();
+		});
+		watcher.on("change", () => {
+			reGenerateSchema();
+		});
+	}
+}
+async function pureGenerate(options, fromWatch) {
+	const start = Date.now();
+	const schemaFile = getSchemaFile(options.schema);
+	const model = await loadSchemaDocument(schemaFile);
+	const outputPath = getOutputPath(options, schemaFile);
+	await runPlugins(schemaFile, model, outputPath, options);
+	if (!options.silent) {
+		console.log(colors.green(`Generation completed successfully in ${Date.now() - start}ms.\n`));
+		if (!fromWatch) console.log(`You can now create a ZenStack client with it.
+
+\`\`\`ts
+import { ZenStackClient } from '@zenstackhq/orm';
+import { schema } from '${path.relative(".", outputPath)}/schema';
+
+const client = new ZenStackClient(schema, {
+    dialect: { ... }
+});
+\`\`\`
+
+Check documentation: https://zenstack.dev/docs/`);
+	}
+	return model;
+}
+async function runPlugins(schemaFile, model, outputPath, options) {
+	const plugins = model.declarations.filter(isPlugin);
+	const processedPlugins = [];
+	for (const plugin of plugins) {
+		const provider = getPluginProvider(plugin);
+		let cliPlugin;
+		if (provider.startsWith("@core/")) {
+			cliPlugin = plugins_exports[provider.slice(6)];
+			if (!cliPlugin) throw new CliError(`Unknown core plugin: ${provider}`);
+		} else {
+			const pluginSourcePath = plugin.$cstNode?.parent?.element.$document?.uri?.fsPath ?? schemaFile;
+			cliPlugin = await loadPluginModule(provider, path.dirname(pluginSourcePath));
+		}
+		if (cliPlugin) {
+			const pluginOptions = getPluginOptions(plugin);
+			if (provider === "@core/typescript") {
+				if (options.lite !== void 0) pluginOptions["lite"] = options.lite;
+				if (options.liteOnly !== void 0) pluginOptions["liteOnly"] = options.liteOnly;
+				if (options.generateModels !== void 0) pluginOptions["generateModels"] = options.generateModels;
+				if (options.generateInput !== void 0) pluginOptions["generateInput"] = options.generateInput;
+			}
+			processedPlugins.push({
+				cliPlugin,
+				pluginOptions
+			});
+		}
+	}
+	[{
+		plugin,
+		options: {
+			lite: options.lite,
+			liteOnly: options.liteOnly,
+			generateModels: options.generateModels,
+			generateInput: options.generateInput
+		}
+	}].forEach(({ plugin, options }) => {
+		if (!processedPlugins.some((p) => p.cliPlugin === plugin)) processedPlugins.unshift({
+			cliPlugin: plugin,
+			pluginOptions: options
+		});
+	});
+	for (const { cliPlugin, pluginOptions } of processedPlugins) {
+		invariant(typeof cliPlugin.generate === "function", `Plugin ${cliPlugin.name} does not have a generate function`);
+		let spinner;
+		if (!options.silent) spinner = ora(cliPlugin.statusText ?? `Running plugin ${cliPlugin.name}`).start();
+		try {
+			await cliPlugin.generate({
+				schemaFile,
+				model,
+				defaultOutputPath: outputPath,
+				pluginOptions
+			});
+			spinner?.succeed();
+		} catch (err) {
+			spinner?.fail();
+			throw err;
+		}
+	}
+}
+function getPluginOptions(plugin) {
+	const result = {};
+	for (const field of plugin.fields) {
+		if (field.name === "provider") continue;
+		const value = getLiteral(field.value) ?? getLiteralArray(field.value);
+		if (value === void 0) {
+			console.warn(`Plugin "${plugin.name}" option "${field.name}" has unsupported value, skipping`);
+			continue;
+		}
+		result[field.name] = value;
+	}
+	return result;
+}
+async function checkForMismatchedPackages(projectPath) {
+	const packages = await getZenStackPackages(projectPath);
+	if (!packages.length) return false;
+	const versions = /* @__PURE__ */ new Set();
+	for (const { version } of packages) if (version) versions.add(version);
+	if (versions.size > 1) {
+		const message = "WARNING: Multiple versions of ZenStack packages detected.\n	This will probably cause issues and break your types.";
+		const slashes = "/".repeat(73);
+		const latestVersion = semver.sort(Array.from(versions)).reverse()[0];
+		console.warn(colors.yellow(`${slashes}\n\n\t${message}\n`));
+		for (const { pkg, version } of packages) {
+			if (!version) continue;
+			if (version === latestVersion) console.log(`\t${pkg.padEnd(32)}\t${colors.green(version)}`);
+			else console.log(`\t${pkg.padEnd(32)}\t${colors.yellow(version)}`);
+		}
+		console.warn(`\n${colors.yellow(slashes)}`);
+		return true;
+	}
+	return false;
+}
+//#endregion
+//#region src/actions/info.ts
+/**
+* CLI action for getting information about installed ZenStack packages
+*/
+async function run$4(projectPath) {
+	const packages = await getZenStackPackages(projectPath);
+	if (!packages.length) {
+		console.error("Unable to locate package.json. Are you in a valid project directory?");
+		return;
+	}
+	console.log("Installed ZenStack Packages:");
+	const versions = /* @__PURE__ */ new Set();
+	for (const { pkg, version } of packages) {
+		if (version) versions.add(version);
+		console.log(`    ${colors.green(pkg.padEnd(20))}\t${version}`);
+	}
+	if (versions.size > 1) console.warn(colors.yellow("WARNING: Multiple versions of Zenstack packages detected. This may cause issues."));
+}
+//#endregion
+//#region src/actions/templates.ts
+const STARTER_ZMODEL = `// This is a sample model to get you started.
+
+/// A sample data source using local sqlite db.
+datasource db {
+    provider = 'sqlite'
+    url = 'file:./dev.db'
+}
+
+/// User model
+model User {
+    id       String @id @default(cuid())
+    email    String @unique @email @length(6, 32)
+    posts    Post[]
+}
+
+/// Post model
+model Post {
+    id        String   @id @default(cuid())
+    createdAt DateTime @default(now())
+    updatedAt DateTime @updatedAt
+    title     String   @length(1, 256)
+    content   String
+    published Boolean  @default(false)
+    author    User     @relation(fields: [authorId], references: [id], onDelete: Cascade)
+    authorId  String
+}
+`;
+//#endregion
+//#region src/actions/init.ts
+/**
+* CLI action for getting information about installed ZenStack packages
+*/
+async function run$3(projectPath) {
+	const packages = [
+		{
+			name: "@zenstackhq/cli@latest",
+			dev: true
+		},
+		{
+			name: "@zenstackhq/schema@latest",
+			dev: false
+		},
+		{
+			name: "@zenstackhq/orm@latest",
+			dev: false
+		}
+	];
+	let pm = await detect();
+	if (!pm) pm = {
+		agent: "npm",
+		name: "npm"
+	};
+	console.log(colors.gray(`Using package manager: ${pm.agent}`));
+	for (const pkg of packages) {
+		const resolved = resolveCommand(pm.agent, "add", [pkg.name, ...pkg.dev ? [pm.agent.startsWith("yarn") || pm.agent === "bun" ? "--dev" : "--save-dev"] : []]);
+		if (!resolved) throw new CliError(`Unable to determine how to install package "${pkg.name}". Please install it manually.`);
+		const spinner = ora(`Installing "${pkg.name}"`).start();
+		try {
+			execSync$1(`${resolved.command} ${resolved.args.join(" ")}`, { cwd: projectPath });
+			spinner.succeed();
+		} catch (e) {
+			spinner.fail();
+			throw e;
+		}
+	}
+	const generationFolder = "zenstack";
+	if (!fs.existsSync(path.join(projectPath, generationFolder))) fs.mkdirSync(path.join(projectPath, generationFolder));
+	if (!fs.existsSync(path.join(projectPath, generationFolder, "schema.zmodel"))) fs.writeFileSync(path.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
+	else console.log(colors.yellow("Schema file already exists. Skipping generation of sample."));
+	console.log(colors.green("ZenStack project initialized successfully!"));
+	console.log(colors.gray(`See "${generationFolder}/schema.zmodel" for your database schema.`));
+	console.log(colors.gray("Run `zenstack generate` to compile the the schema into a TypeScript file."));
+}
+//#endregion
+//#region src/actions/seed.ts
+/**
+* CLI action for seeding the database.
+*/
+async function run$2(options, args) {
+	const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+	if (!pkgJsonConfig.seed) {
+		if (!options.noWarnings) console.warn(colors.yellow("No seed script defined in package.json. Skipping seeding."));
+		return;
+	}
+	const command = `${pkgJsonConfig.seed}${args.length > 0 ? " " + args.join(" ") : ""}`;
+	if (options.printStatus) console.log(colors.gray(`Running seed script "${command}"...`));
+	try {
+		await execaCommand(command, {
+			stdout: "inherit",
+			stderr: "inherit"
+		});
+	} catch (err) {
+		console.error(colors.red(err instanceof Error ? err.message : String(err)));
+		throw new CliError("Failed to seed the database. Please check the error message above for details.");
+	}
+}
+//#endregion
+//#region src/actions/migrate.ts
+/**
+* CLI action for migration-related commands
+*/
+async function run$1(command, options) {
+	const schemaFile = getSchemaFile(options.schema);
+	await requireDataSourceUrl(schemaFile);
+	const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, options.migrations ? path.dirname(options.migrations) : void 0);
+	try {
+		switch (command) {
+			case "dev":
+				await runDev(prismaSchemaFile, options);
+				break;
+			case "reset":
+				await runReset(prismaSchemaFile, options);
+				break;
+			case "deploy":
+				await runDeploy(prismaSchemaFile, options);
+				break;
+			case "status":
+				await runStatus(prismaSchemaFile, options);
+				break;
+			case "resolve":
+				await runResolve(prismaSchemaFile, options);
+				break;
+		}
+	} finally {
+		if (fs.existsSync(prismaSchemaFile)) fs.unlinkSync(prismaSchemaFile);
+	}
+}
+function runDev(prismaSchemaFile, options) {
+	try {
+		execPrisma([
+			"migrate dev",
+			` --schema "${prismaSchemaFile}"`,
+			" --skip-generate",
+			" --skip-seed",
+			options.name ? ` --name "${options.name}"` : "",
+			options.createOnly ? " --create-only" : ""
+		].join(""));
+	} catch (err) {
+		handleSubProcessError(err);
+	}
+}
+async function runReset(prismaSchemaFile, options) {
+	try {
+		execPrisma([
+			"migrate reset",
+			` --schema "${prismaSchemaFile}"`,
+			" --skip-generate",
+			" --skip-seed",
+			options.force ? " --force" : ""
+		].join(""));
+	} catch (err) {
+		handleSubProcessError(err);
+	}
+	if (!options.skipSeed) await run$2({
+		noWarnings: true,
+		printStatus: true
+	}, []);
+}
+function runDeploy(prismaSchemaFile, _options) {
+	try {
+		execPrisma(["migrate deploy", ` --schema "${prismaSchemaFile}"`].join(""));
+	} catch (err) {
+		handleSubProcessError(err);
+	}
+}
+function runStatus(prismaSchemaFile, _options) {
+	try {
+		execPrisma(`migrate status --schema "${prismaSchemaFile}"`);
+	} catch (err) {
+		handleSubProcessError(err);
+	}
+}
+function runResolve(prismaSchemaFile, options) {
+	if (!options.applied && !options.rolledBack) throw new CliError("Either --applied or --rolled-back option must be provided");
+	try {
+		execPrisma([
+			"migrate resolve",
+			` --schema "${prismaSchemaFile}"`,
+			options.applied ? ` --applied "${options.applied}"` : "",
+			options.rolledBack ? ` --rolled-back "${options.rolledBack}"` : ""
+		].join(""));
+	} catch (err) {
+		handleSubProcessError(err);
+	}
+}
+function handleSubProcessError(err) {
+	if (err instanceof Error && "status" in err && typeof err.status === "number") process.exit(err.status);
+	else process.exit(1);
+}
+//#endregion
+//#region src/utils/version-utils.ts
+const CHECK_VERSION_TIMEOUT = 2e3;
+const VERSION_CHECK_TAG = "latest";
+function getVersion() {
+	try {
+		const _dirname = typeof __dirname !== "undefined" ? __dirname : path.dirname(fileURLToPath(import.meta.url));
+		return JSON.parse(fs.readFileSync(path.join(_dirname, "../package.json"), "utf8")).version;
+	} catch {
+		return;
+	}
+}
+async function checkNewVersion() {
+	const currVersion = getVersion();
+	let latestVersion;
+	try {
+		latestVersion = await getLatestVersion();
+	} catch {
+		return;
+	}
+	if (latestVersion && currVersion && semver.gt(latestVersion, currVersion)) console.log(`A newer version ${colors.cyan(latestVersion)} is available.`);
+}
+async function getLatestVersion() {
+	const fetchResult = await fetch(`https://registry.npmjs.org/@zenstackhq/cli/${VERSION_CHECK_TAG}`, {
+		headers: { accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*" },
+		signal: AbortSignal.timeout(CHECK_VERSION_TIMEOUT)
+	});
+	if (fetchResult.ok) {
+		const latestVersion = (await fetchResult.json())?.version;
+		if (typeof latestVersion === "string" && semver.valid(latestVersion)) return latestVersion;
+	}
+	throw new Error("invalid npm registry response");
+}
+//#endregion
+//#region src/actions/proxy.ts
+async function run(options) {
+	const allowedLogLevels = ["error", "query"];
+	const log = options.logLevel?.filter((level) => allowedLogLevels.includes(level));
+	const schemaFile = getSchemaFile(options.schema);
+	console.log(colors.gray(`Loading ZModel schema from: ${schemaFile}`));
+	let outputPath = getOutputPath(options, schemaFile);
+	if (!path.isAbsolute(outputPath)) outputPath = path.resolve(process.cwd(), outputPath);
+	const dataSource = (await loadSchemaDocument(schemaFile)).declarations.find(isDataSource);
+	let databaseUrl = options.databaseUrl;
+	if (!databaseUrl) {
+		const schemaUrl = dataSource?.fields.find((f) => f.name === "url")?.value;
+		if (!schemaUrl) throw new CliError(`The schema's "datasource" does not have a "url" field, please provide it with -d option.`);
+		databaseUrl = evaluateUrl(schemaUrl);
+	}
+	const dialect = await createDialect(getStringLiteral(dataSource?.fields.find((f) => f.name === "provider")?.value), databaseUrl, outputPath);
+	const schemaModule = await createJiti(typeof __filename !== "undefined" ? __filename : import.meta.url).import(path.join(outputPath, "schema"));
+	const schema = schemaModule.schema;
+	const omit = {};
+	for (const [modelName, modelDef] of Object.entries(schema.models)) {
+		const omitFields = {};
+		for (const [fieldName, fieldDef] of Object.entries(modelDef.fields)) if (fieldDef.computed === true || fieldDef.type === "Unsupported") omitFields[fieldName] = true;
+		if (Object.keys(omitFields).length > 0) omit[modelName] = omitFields;
+	}
+	const db = new ZenStackClient(schema, {
+		dialect,
+		log: log && log.length > 0 ? log : void 0,
+		omit: Object.keys(omit).length > 0 ? omit : void 0,
+		skipValidationForComputedFields: true
+	});
+	try {
+		await db.$connect();
+	} catch (err) {
+		throw new CliError(`Failed to connect to the database: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	startServer(db, schemaModule.schema, options);
+}
+function evaluateUrl(schemaUrl) {
+	if (isLiteralExpr(schemaUrl)) return getStringLiteral(schemaUrl);
+	else if (isInvocationExpr(schemaUrl)) {
+		const envName = getStringLiteral(schemaUrl.args[0]?.value);
+		const envValue = process.env[envName];
+		if (!envValue) throw new CliError(`Environment variable ${envName} is not set`);
+		return envValue;
+	} else throw new CliError(`Unable to resolve the "url" field value.`);
+}
+function redactDatabaseUrl(url) {
+	try {
+		const parsedUrl = new URL(url);
+		if (parsedUrl.password) parsedUrl.password = "***";
+		if (parsedUrl.username) parsedUrl.username = "***";
+		return parsedUrl.toString();
+	} catch {
+		return url;
+	}
+}
+async function createDialect(provider, databaseUrl, outputPath) {
+	switch (provider) {
+		case "sqlite": {
+			let SQLite;
+			try {
+				SQLite = (await import("better-sqlite3")).default;
+			} catch {
+				throw new CliError(`Package "better-sqlite3" is required for SQLite support. Please install it with: npm install better-sqlite3`);
+			}
+			let resolvedUrl = databaseUrl.trim();
+			if (resolvedUrl.startsWith("file:")) {
+				const filePath = resolvedUrl.substring(5);
+				if (!path.isAbsolute(filePath)) resolvedUrl = path.join(outputPath, filePath);
+			}
+			console.log(colors.gray(`Connecting to SQLite database at: ${resolvedUrl}`));
+			return new SqliteDialect({ database: new SQLite(resolvedUrl) });
+		}
+		case "postgresql": {
+			let PgPool;
+			try {
+				PgPool = (await import("pg")).Pool;
+			} catch {
+				throw new CliError(`Package "pg" is required for PostgreSQL support. Please install it with: npm install pg`);
+			}
+			console.log(colors.gray(`Connecting to PostgreSQL database at: ${redactDatabaseUrl(databaseUrl)}`));
+			return new PostgresDialect({ pool: new PgPool({ connectionString: databaseUrl }) });
+		}
+		case "mysql": {
+			let createMysqlPool;
+			try {
+				createMysqlPool = (await import("mysql2")).createPool;
+			} catch {
+				throw new CliError(`Package "mysql2" is required for MySQL support. Please install it with: npm install mysql2`);
+			}
+			console.log(colors.gray(`Connecting to MySQL database at: ${redactDatabaseUrl(databaseUrl)}`));
+			return new MysqlDialect({ pool: createMysqlPool(databaseUrl) });
+		}
+		default: throw new CliError(`Unsupported database provider: ${provider}`);
+	}
+}
+function createProxyApp(client, schema) {
+	const app = express();
+	app.use(cors());
+	app.use(express.json({ limit: "5mb" }));
+	app.use(express.urlencoded({
+		extended: true,
+		limit: "5mb"
+	}));
+	app.use("/api/model", ZenStackMiddleware({
+		apiHandler: new RPCApiHandler({ schema }),
+		getClient: () => client
+	}));
+	app.get("/api/schema", (_req, res) => {
+		res.json({
+			...schema,
+			zenstackVersion: getVersion()
+		});
+	});
+	return app;
+}
+function startServer(client, schema, options) {
+	const server = createProxyApp(client, schema).listen(options.port, () => {
+		console.log(`ZenStack proxy server is running on port: ${options.port}`);
+		console.log(`You can visit ZenStack Studio at: ${colors.blue("https://studio.zenstack.dev")}`);
+	});
+	server.on("error", (err) => {
+		if (err.code === "EADDRINUSE") console.error(colors.red(`Port ${options.port} is already in use. Please choose a different port using -p option.`));
+		else throw new CliError(`Failed to start the server: ${err.message}`);
+		process.exit(1);
+	});
+	process.on("SIGTERM", async () => {
+		server.close(() => {
+			console.log("\nZenStack proxy server closed");
+		});
+		await client.$disconnect();
+		process.exit(0);
+	});
+	process.on("SIGINT", async () => {
+		server.close(() => {
+			console.log("\nZenStack proxy server closed");
+		});
+		await client.$disconnect();
+		process.exit(0);
+	});
+}
+//#endregion
+//#region src/constants.ts
+const TELEMETRY_TRACKING_TOKEN = "74944eb779d7d3b4ce185be843fde9fc";
+//#endregion
+//#region src/utils/is-ci.ts
+const isInCi = env["CI"] !== "0" && env["CI"] !== "false" && ("CI" in env || "CONTINUOUS_INTEGRATION" in env || Object.keys(env).some((key) => key.startsWith("CI_")));
+//#endregion
+//#region src/utils/is-docker.ts
+let isDockerCached;
+function hasDockerEnv() {
+	try {
+		fs.statSync("/.dockerenv");
+		return true;
+	} catch {
+		return false;
+	}
+}
+function hasDockerCGroup() {
+	try {
+		return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+	} catch {
+		return false;
+	}
+}
+function isDocker() {
+	if (isDockerCached === void 0) isDockerCached = hasDockerEnv() || hasDockerCGroup();
+	return isDockerCached;
+}
+//#endregion
+//#region src/utils/is-container.ts
+let cachedResult;
+const hasContainerEnv = () => {
+	try {
+		fs.statSync("/run/.containerenv");
+		return true;
+	} catch {
+		return false;
+	}
+};
+function isInContainer() {
+	if (cachedResult === void 0) cachedResult = hasContainerEnv() || isDocker();
+	return cachedResult;
+}
+//#endregion
+//#region src/utils/is-wsl.ts
+const isWsl = () => {
+	if (process$1.platform !== "linux") return false;
+	if (os.release().toLowerCase().includes("microsoft")) return true;
+	try {
+		return fs.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+	} catch {
+		return false;
+	}
+};
+//#endregion
+//#region src/utils/machine-id-utils.ts
+const { platform } = process;
+const guid = {
+	darwin: "ioreg -rd1 -c IOPlatformExpertDevice",
+	win32: `${{
+		native: "%windir%\\System32",
+		mixed: "%windir%\\sysnative\\cmd.exe /c %windir%\\System32"
+	}[isWindowsProcessMixedOrNativeArchitecture()]}\\REG.exe QUERY HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid`,
+	linux: "( cat /var/lib/dbus/machine-id /etc/machine-id 2> /dev/null || hostname 2> /dev/null) | head -n 1 || :",
+	freebsd: "kenv -q smbios.system.uuid || sysctl -n kern.hostuuid"
+};
+function isWindowsProcessMixedOrNativeArchitecture() {
+	if (process.arch === "ia32" && process.env.hasOwnProperty("PROCESSOR_ARCHITEW6432")) return "mixed";
+	return "native";
+}
+function hash(guid) {
+	return createHash("sha256").update(guid).digest("hex");
+}
+function expose(result) {
+	switch (platform) {
+		case "darwin": return result.split("IOPlatformUUID")[1]?.split("\n")[0]?.replace(/=|\s+|"/gi, "").toLowerCase();
+		case "win32": return result.toString().split("REG_SZ")[1]?.replace(/\r+|\n+|\s+/gi, "").toLowerCase();
+		case "linux": return result.toString().replace(/\r+|\n+|\s+/gi, "").toLowerCase();
+		case "freebsd": return result.toString().replace(/\r+|\n+|\s+/gi, "").toLowerCase();
+		default: throw new Error(`Unsupported platform: ${process.platform}`);
+	}
+}
+function getMachineId() {
+	if (!(platform in guid)) return randomUUID();
+	try {
+		const id = expose(execSync(guid[platform]).toString());
+		if (!id) return randomUUID();
+		return hash(id);
+	} catch {
+		return randomUUID();
+	}
+}
+//#endregion
+//#region src/telemetry.ts
+/**
+* Utility class for sending telemetry
+*/
+var Telemetry = class {
+	mixpanel;
+	hostId = getMachineId();
+	sessionid = randomUUID();
+	_os_type = os$1.type();
+	_os_release = os$1.release();
+	_os_arch = os$1.arch();
+	_os_version = os$1.version();
+	_os_platform = os$1.platform();
+	version = getVersion();
+	prismaVersion = this.getPrismaVersion();
+	isDocker = isDocker();
+	isWsl = isWsl();
+	isContainer = isInContainer();
+	isCi = isInCi;
+	constructor() {
+		if (process.env["DO_NOT_TRACK"] !== "1" && "<TELEMETRY_TRACKING_TOKEN>") this.mixpanel = init(TELEMETRY_TRACKING_TOKEN, { geolocate: true });
+	}
+	get isTracking() {
+		return !!this.mixpanel;
+	}
+	track(event, properties = {}) {
+		if (this.mixpanel) {
+			const payload = {
+				distinct_id: this.hostId,
+				session: this.sessionid,
+				time: /* @__PURE__ */ new Date(),
+				$os: this._os_type,
+				osType: this._os_type,
+				osRelease: this._os_release,
+				osPlatform: this._os_platform,
+				osArch: this._os_arch,
+				osVersion: this._os_version,
+				nodeVersion: process.version,
+				version: this.version,
+				prismaVersion: this.prismaVersion,
+				isDocker: this.isDocker,
+				isWsl: this.isWsl,
+				isContainer: this.isContainer,
+				isCi: this.isCi,
+				...properties
+			};
+			this.mixpanel.track(event, payload);
+		}
+	}
+	trackError(err) {
+		this.track("cli:error", {
+			message: err.message,
+			stack: err.stack
+		});
+	}
+	async trackSpan(startEvent, completeEvent, errorEvent, properties, action) {
+		this.track(startEvent, properties);
+		const start = Date.now();
+		let success = true;
+		try {
+			return await action();
+		} catch (err) {
+			this.track(errorEvent, {
+				message: err.message,
+				stack: err.stack,
+				...properties
+			});
+			success = false;
+			throw err;
+		} finally {
+			this.track(completeEvent, {
+				duration: Date.now() - start,
+				success,
+				...properties
+			});
+		}
+	}
+	async trackCommand(command, action) {
+		await this.trackSpan("cli:command:start", "cli:command:complete", "cli:command:error", { command }, action);
+	}
+	async trackCli(action) {
+		await this.trackSpan("cli:start", "cli:complete", "cli:error", {}, action);
+	}
+	getPrismaVersion() {
+		try {
+			const packageJsonPath = import.meta.resolve("prisma/package.json");
+			const packageJsonUrl = new URL(packageJsonPath);
+			return JSON.parse(fs.readFileSync(packageJsonUrl, "utf8")).version;
+		} catch {
+			return;
+		}
+	}
+};
+const telemetry = new Telemetry();
+//#endregion
+//#region src/index.ts
+const generateAction = async (options) => {
+	await telemetry.trackCommand("generate", () => run$5(options));
+};
+const migrateAction = async (subCommand, options) => {
+	await telemetry.trackCommand(`migrate ${subCommand}`, () => run$1(subCommand, options));
+};
+const dbAction = async (subCommand, options) => {
+	await telemetry.trackCommand(`db ${subCommand}`, () => run$7(subCommand, options));
+};
+const infoAction = async (projectPath) => {
+	await telemetry.trackCommand("info", () => run$4(projectPath));
+};
+const initAction = async (projectPath) => {
+	await telemetry.trackCommand("init", () => run$3(projectPath));
+};
+const checkAction = async (options) => {
+	await telemetry.trackCommand("check", () => run$8(options));
+};
+const formatAction = async (options) => {
+	await telemetry.trackCommand("format", () => run$6(options));
+};
+const seedAction = async (options, args) => {
+	await telemetry.trackCommand("db seed", () => run$2(options, args));
+};
+const proxyAction = async (options) => {
+	await telemetry.trackCommand("proxy", () => run(options));
+};
+function triStateBooleanOption(flag, description) {
+	return new Option(flag, description).choices(["true", "false"]).argParser((value) => {
+		if (value === void 0 || value === "true") return true;
+		if (value === "false") return false;
+		throw new CliError(`Invalid value for ${flag}: ${value}`);
+	});
+}
+function createProgram() {
+	const program = new Command("zen").alias("zenstack").helpOption("-h, --help", "Show this help message").version(getVersion(), "-v --version", "Show CLI version");
+	const schemaExtensions = ZModelLanguageMetaData.fileExtensions.join(", ");
+	program.description(`${colors.bold.blue("ζ")} ZenStack is the modern data layer for TypeScript apps.\n\nDocumentation: https://zenstack.dev/docs`).showHelpAfterError().showSuggestionAfterError();
+	const schemaOption = new Option("--schema <file>", `schema file (with extension ${schemaExtensions}). Defaults to "zenstack/schema.zmodel" unless specified in package.json.`);
+	const noVersionCheckOption = new Option("--no-version-check", "do not check for new version");
+	const noTipsOption = new Option("--no-tips", "do not show usage tips");
+	program.command("generate").description("Run code generation plugins").addOption(schemaOption).addOption(noVersionCheckOption).addOption(noTipsOption).addOption(new Option("-o, --output <path>", "default output directory for code generation")).addOption(new Option("-w, --watch", "enable watch mode").default(false)).addOption(triStateBooleanOption("--lite [boolean]", "also generate a lite version of schema without attributes, defaults to false")).addOption(triStateBooleanOption("--lite-only [boolean]", "only generate lite version of schema without attributes, defaults to false")).addOption(triStateBooleanOption("--generate-models [boolean]", "generate models.ts file, defaults to true")).addOption(triStateBooleanOption("--generate-input [boolean]", "generate input.ts file, defaults to true")).addOption(new Option("--silent", "suppress all output except errors").default(false)).action(generateAction);
+	const migrateCommand = program.command("migrate").description("Run database schema migration related tasks.");
+	const migrationsOption = new Option("--migrations <path>", "path that contains the \"migrations\" directory");
+	migrateCommand.command("dev").addOption(schemaOption).addOption(noVersionCheckOption).addOption(new Option("-n, --name <name>", "migration name")).addOption(new Option("--create-only", "only create migration, do not apply")).addOption(migrationsOption).description("Create a migration from changes in schema and apply it to the database").action((options) => migrateAction("dev", options));
+	migrateCommand.command("reset").addOption(schemaOption).addOption(new Option("--force", "skip the confirmation prompt")).addOption(migrationsOption).addOption(new Option("--skip-seed", "skip seeding the database after reset")).addOption(noVersionCheckOption).description("Reset your database and apply all migrations, all data will be lost").addHelpText("after", "\nIf there is a seed script defined in package.json, it will be run after the reset. Use --skip-seed to skip it.").action((options) => migrateAction("reset", options));
+	migrateCommand.command("deploy").addOption(schemaOption).addOption(noVersionCheckOption).addOption(migrationsOption).description("Deploy your pending migrations to your production/staging database").action((options) => migrateAction("deploy", options));
+	migrateCommand.command("status").addOption(schemaOption).addOption(noVersionCheckOption).addOption(migrationsOption).description("Check the status of your database migrations").action((options) => migrateAction("status", options));
+	migrateCommand.command("resolve").addOption(schemaOption).addOption(noVersionCheckOption).addOption(migrationsOption).addOption(new Option("--applied <migration>", "record a specific migration as applied")).addOption(new Option("--rolled-back <migration>", "record a specific migration as rolled back")).description("Resolve issues with database migrations in deployment databases").action((options) => migrateAction("resolve", options));
+	const dbCommand = program.command("db").description("Manage your database schema during development");
+	dbCommand.command("push").description("Push the state from your schema to your database").addOption(schemaOption).addOption(noVersionCheckOption).addOption(new Option("--accept-data-loss", "ignore data loss warnings")).addOption(new Option("--force-reset", "force a reset of the database before push")).action((options) => dbAction("push", options));
+	dbCommand.command("pull").description("Introspect your database.").addOption(schemaOption).addOption(noVersionCheckOption).addOption(new Option("-o, --output <path>", "set custom output path for the introspected schema. If a file path is provided, all schemas are merged into that single file. If a directory path is provided, files are written to the directory and imports are kept.")).addOption(new Option("--model-casing <pascal|camel|snake|none>", "set the casing of generated models").default("pascal")).addOption(new Option("--field-casing <pascal|camel|snake|none>", "set the casing of generated fields").default("camel")).addOption(new Option("--always-map", "always add @map and @@map attributes to models and fields").default(false)).addOption(new Option("--quote <double|single>", "set the quote style of generated schema files").default("single")).addOption(new Option("--indent <number>", "set the indentation of the generated schema files").default(4)).action((options) => dbAction("pull", options));
+	dbCommand.command("seed").description("Seed the database").allowExcessArguments(true).addHelpText("after", `
+Seed script is configured under the "zenstack.seed" field in package.json.
+E.g.:
+{
+    "zenstack": {
+        "seed": "ts-node ./zenstack/seed.ts"
+    }
+}
+
+Arguments following -- are passed to the seed script. E.g.: "zen db seed -- --users 10"`).addOption(noVersionCheckOption).action((options, command) => seedAction(options, command.args));
+	program.command("info").description("Get information of installed ZenStack packages").argument("[path]", "project path", ".").addOption(noVersionCheckOption).action(infoAction);
+	program.command("init").description("Initialize an existing project for ZenStack").argument("[path]", "project path", ".").addOption(noVersionCheckOption).action(initAction);
+	program.command("check").description("Check a ZModel schema for syntax or semantic errors").addOption(schemaOption).addOption(noVersionCheckOption).action(checkAction);
+	program.command("format").description("Format a ZModel schema file").addOption(schemaOption).addOption(noVersionCheckOption).action(formatAction);
+	program.command("proxy").alias("studio").description("Start the ZenStack proxy server").addOption(schemaOption).addOption(new Option("-p, --port <port>", "port to run the proxy server on").default(2311)).addOption(new Option("-o, --output <path>", "output directory for `zen generate` command")).addOption(new Option("-d, --databaseUrl <url>", "database connection URL")).addOption(new Option("-l, --logLevel <level...>", "Query log levels (e.g., query, error)")).addOption(noVersionCheckOption).action(proxyAction);
+	program.addHelpCommand("help [command]", "Display help for a command");
+	program.hook("preAction", async (_thisCommand, actionCommand) => {
+		if (actionCommand.getOptionValue("versionCheck") !== false) await checkNewVersion();
+	});
+	return program;
+}
+async function main() {
+	let exitCode = 0;
+	const program = createProgram();
+	program.exitOverride();
+	try {
+		await telemetry.trackCli(async () => {
+			await program.parseAsync();
+		});
+	} catch (e) {
+		if (e instanceof CommanderError) exitCode = e.exitCode;
+		else if (e instanceof CliError) {
+			console.error(colors.red(e.message));
+			exitCode = 1;
+		} else {
+			console.error(colors.red(`Unhandled error: ${e}`));
+			exitCode = 1;
+		}
+	}
+	if (program.args.includes("generate") && (program.args.includes("-w") || program.args.includes("--watch")) || ["proxy", "studio"].some((cmd) => program.args.includes(cmd))) return;
+	if (telemetry.isTracking) setTimeout(() => {
+		process.exit(exitCode);
+	}, 200);
+	else process.exit(exitCode);
+}
+main();
+//#endregion
+export {};
+
+//# sourceMappingURL=index.mjs.map