@zenstackhq/cli 3.5.6 → 3.6.1

package/dist/index.js

@@ -1,4224 +0,0 @@
-var __defProp = Object.defineProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/index.ts
-import { ZModelLanguageMetaData as ZModelLanguageMetaData2 } from "@zenstackhq/language";
-import colors12 from "colors";
-import { Command, CommanderError, Option } from "commander";
-import "dotenv/config";
-
-// src/actions/check.ts
-import { isPlugin } from "@zenstackhq/language/ast";
-import colors2 from "colors";
-import path2 from "path";
-
-// src/actions/action-utils.ts
-import { invariant } from "@zenstackhq/common-helpers";
-import { loadDocument } from "@zenstackhq/language";
-import { isDataSource } from "@zenstackhq/language/ast";
-import { PrismaSchemaGenerator } from "@zenstackhq/sdk";
-import colors from "colors";
-import { createJiti } from "jiti";
-import fs from "fs";
-import { createRequire } from "module";
-import path from "path";
-import { pathToFileURL } from "url";
-import terminalLink from "terminal-link";
-import { z } from "zod";
-
-// src/cli-error.ts
-var CliError = class extends Error {
-  static {
-    __name(this, "CliError");
-  }
-};
-
-// 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").');
-  }
-}
-__name(getSchemaFile, "getSchemaFile");
-async function loadSchemaDocument(schemaFile, opts = {}) {
-  const returnServices = opts.returnServices ?? false;
-  const mergeImports = opts.mergeImports ?? true;
-  const loadResult = await loadDocument(schemaFile, [], mergeImports);
-  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;
-}
-__name(loadSchemaDocument, "loadSchemaDocument");
-function handleSubProcessError(err) {
-  if (err instanceof Error && "status" in err && typeof err.status === "number") {
-    process.exit(err.status);
-  } else {
-    process.exit(1);
-  }
-}
-__name(handleSubProcessError, "handleSubProcessError");
-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;
-}
-__name(generateTempPrismaSchema, "generateTempPrismaSchema");
-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;
-}
-__name(getPkgJsonConfig, "getPkgJsonConfig");
-function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
-  if (!names.some((name) => !!name)) {
-    return void 0;
-  }
-  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);
-}
-__name(findUp, "findUp");
-async function requireDataSourceUrl(schemaFile) {
-  const zmodel = await loadSchemaDocument(schemaFile);
-  const dataSource = zmodel.declarations.find(isDataSource);
-  if (!dataSource?.fields.some((f) => f.name === "url")) {
-    throw new CliError(`The schema's "datasource" must have a "url" field to use this command.`);
-  }
-}
-__name(requireDataSourceUrl, "requireDataSourceUrl");
-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);
-  }
-}
-__name(getOutputPath, "getOutputPath");
-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 require2 = createRequire(pkgJsonFile);
-  const result = packages.map((pkg) => {
-    try {
-      const depPkgJson = require2(`${pkg}/package.json`);
-      if (depPkgJson.private) {
-        return void 0;
-      }
-      return {
-        pkg,
-        version: depPkgJson.version
-      };
-    } catch {
-      return {
-        pkg,
-        version: void 0
-      };
-    }
-  });
-  return result.filter((p) => !!p);
-}
-__name(getZenStackPackages, "getZenStackPackages");
-function getPluginProvider(plugin3) {
-  const providerField = plugin3.fields.find((f) => f.name === "provider");
-  invariant(providerField, `Plugin ${plugin3.name} does not have a provider field`);
-  const provider = providerField.value.value;
-  return provider;
-}
-__name(getPluginProvider, "getPluginProvider");
-async function loadPluginModule(provider, basePath) {
-  if (provider.toLowerCase().endsWith(".zmodel")) {
-    return void 0;
-  }
-  let moduleSpec = provider;
-  if (moduleSpec.startsWith(".")) {
-    moduleSpec = path.resolve(basePath, moduleSpec);
-  }
-  const importAsEsm = /* @__PURE__ */ __name(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}`);
-    }
-  }, "importAsEsm");
-  const jiti = createJiti(pathToFileURL(basePath).toString());
-  const importAsTs = /* @__PURE__ */ __name(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}`);
-    }
-  }, "importAsTs");
-  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}`);
-  }
-}
-__name(loadPluginModule, "loadPluginModule");
-var FETCH_CLI_MAX_TIME = 1e3;
-var CLI_CONFIG_ENDPOINT = "https://zenstack.dev/config/cli-v3.json";
-var usageTipsSchema = z.object({
-  notifications: z.array(z.object({
-    title: z.string(),
-    url: z.url().optional(),
-    active: z.boolean()
-  }))
-});
-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);
-      }
-    }
-  };
-}
-__name(startUsageTipsFetch, "startUsageTipsFetch");
-
-// src/actions/check.ts
-async function run(options) {
-  const schemaFile = getSchemaFile(options.schema);
-  try {
-    const model = await loadSchemaDocument(schemaFile);
-    await checkPluginResolution(schemaFile, model);
-    console.log(colors2.green("\u2713 Schema validation completed successfully."));
-  } catch (error) {
-    console.error(colors2.red("\u2717 Schema validation failed."));
-    throw error;
-  }
-}
-__name(run, "run");
-async function checkPluginResolution(schemaFile, model) {
-  const plugins = model.declarations.filter(isPlugin);
-  for (const plugin3 of plugins) {
-    const provider = getPluginProvider(plugin3);
-    if (!provider.startsWith("@core/")) {
-      const pluginSourcePath = plugin3.$cstNode?.parent?.element.$document?.uri?.fsPath ?? schemaFile;
-      await loadPluginModule(provider, path2.dirname(pluginSourcePath));
-    }
-  }
-}
-__name(checkPluginResolution, "checkPluginResolution");
-
-// src/actions/db.ts
-import { formatDocument, ZModelCodeGenerator } from "@zenstackhq/language";
-import { DataModel, Enum } from "@zenstackhq/language/ast";
-import colors4 from "colors";
-import fs2 from "fs";
-import path3 from "path";
-import ora from "ora";
-
-// src/utils/exec-utils.ts
-import { execSync as _exec } from "child_process";
-import { fileURLToPath } from "url";
-function execSync(cmd, options) {
-  const { env: env2, ...restOptions } = options ?? {};
-  const mergedEnv = env2 ? {
-    ...process.env,
-    ...env2
-  } : void 0;
-  _exec(cmd, {
-    encoding: "utf-8",
-    stdio: options?.stdio ?? "inherit",
-    env: mergedEnv,
-    ...restOptions
-  });
-}
-__name(execSync, "execSync");
-function execPackage(cmd, options) {
-  const packageManager = process?.versions?.["bun"] ? "bunx" : "npx";
-  execSync(`${packageManager} ${cmd}`, options);
-}
-__name(execPackage, "execPackage");
-function execPrisma(args, options) {
-  let prismaPath;
-  try {
-    if (typeof import.meta.resolve === "function") {
-      prismaPath = fileURLToPath(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(`node "${prismaPath}" ${args}`, _options);
-}
-__name(execPrisma, "execPrisma");
-
-// src/actions/pull/index.ts
-import colors3 from "colors";
-import { isEnum } from "@zenstackhq/language/ast";
-import { DataFieldAttributeFactory, DataFieldFactory, DataModelFactory, EnumFactory } from "@zenstackhq/language/factory";
-import { AstUtils } from "langium";
-import { lowerCaseFirst } from "@zenstackhq/common-helpers";
-
-// src/actions/pull/utils.ts
-import { isInvocationExpr } from "@zenstackhq/language/ast";
-import { getLiteralArray, getStringLiteral } from "@zenstackhq/language/utils";
-function isDatabaseManagedAttribute(name) {
-  return [
-    "@relation",
-    "@id",
-    "@unique"
-  ].includes(name) || name.startsWith("@db.");
-}
-__name(isDatabaseManagedAttribute, "isDatabaseManagedAttribute");
-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
-    ]
-  };
-}
-__name(getDatasource, "getDatasource");
-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 = /* @__PURE__ */ __name((name) => `${schema && includeSchema ? `${schema}.` : ""}${name}`, "formatName");
-  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);
-}
-__name(getDbName, "getDbName");
-function getRelationFkName(decl) {
-  const relationAttr = decl?.attributes.find((a) => a.decl.ref?.name === "@relation");
-  const schemaAttrValue = relationAttr?.args.find((a) => a.name === "map")?.value;
-  return schemaAttrValue?.value;
-}
-__name(getRelationFkName, "getRelationFkName");
-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;
-}
-__name(getRelationFieldsKey, "getRelationFieldsKey");
-function getDeclarationRef(type2, name, services) {
-  const node = services.shared.workspace.IndexManager.allElements(type2).find((m) => m.node && getDbName(m.node) === name)?.node;
-  if (!node) throw new CliError(`Declaration not found: ${name}`);
-  return node;
-}
-__name(getDeclarationRef, "getDeclarationRef");
-function getEnumRef(name, services) {
-  return getDeclarationRef("Enum", name, services);
-}
-__name(getEnumRef, "getEnumRef");
-function getAttributeRef(name, services) {
-  return getDeclarationRef("Attribute", name, services);
-}
-__name(getAttributeRef, "getAttributeRef");
-function getFunctionRef(name, services) {
-  return getDeclarationRef("FunctionDecl", name, services);
-}
-__name(getFunctionRef, "getFunctionRef");
-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);
-}
-__name(normalizeFloatDefault, "normalizeFloatDefault");
-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);
-}
-__name(normalizeDecimalDefault, "normalizeDecimalDefault");
-
-// 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}`
-  };
-}
-__name(resolveNameCasing, "resolveNameCasing");
-function isAllUpperCase(str) {
-  return str === str.toUpperCase();
-}
-__name(isAllUpperCase, "isAllUpperCase");
-function toPascalCase(str) {
-  if (isAllUpperCase(str)) return str;
-  return str.replace(/[_\- ]+(\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toUpperCase());
-}
-__name(toPascalCase, "toPascalCase");
-function toCamelCase(str) {
-  if (isAllUpperCase(str)) return str;
-  return str.replace(/[_\- ]+(\w)/g, (_, c) => c.toUpperCase()).replace(/^\w/, (c) => c.toLowerCase());
-}
-__name(toCamelCase, "toCamelCase");
-function toSnakeCase(str) {
-  if (isAllUpperCase(str)) return str;
-  return str.replace(/[- ]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
-}
-__name(toSnakeCase, "toSnakeCase");
-
-// 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(colors3.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: name2, modified: modified2 } = resolveNameCasing(options.fieldCasing, v);
-        factory.addField((builder) => {
-          builder.setName(name2);
-          if (modified2 || options.alwaysMap) builder.addAttribute((builder2) => builder2.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 = /* @__PURE__ */ __name((_node, _property, _refNode, refText) => ({
-      $refText: refText
-    }), "dummyBuildReference");
-    oldModel.declarations.filter((d) => isEnum(d)).forEach((d) => {
-      const copy = AstUtils.copyAstNode(d, dummyBuildReference);
-      copy.$container = model;
-      model.declarations.push(copy);
-    });
-  }
-}
-__name(syncEnums, "syncEnums");
-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: name2, modified: modified2 } = resolveNameCasing(options.fieldCasing, column.name);
-    const builtinType = provider.getBuiltinType(column.datatype);
-    modelFactory.addField((builder) => {
-      builder.setName(name2);
-      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));
-      }
-      const fieldAttrs = provider.getFieldAttributes({
-        fieldName: column.name,
-        fieldType: builtinType.type,
-        datatype: column.datatype,
-        length: column.length,
-        precision: column.precision,
-        services
-      });
-      fieldAttrs.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);
-          const isDefaultName = !column.unique_name || column.unique_name === `${table.name}_${column.name}_key` || column.unique_name === column.name;
-          if (!isDefaultName) {
-            b.addArg((ab) => ab.StringLiteral.setValue(column.unique_name), "map");
-          }
-          return b;
-        });
-      }
-      if (modified2 || options.alwaysMap) {
-        builder.addAttribute((ab) => ab.setDecl(fieldMapAttribute).addArg((ab2) => ab2.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;
-    }));
-  }
-  const hasUniqueConstraint = table.columns.some((c) => c.unique || c.pk) || table.indexes.some((i) => i.unique);
-  if (!hasUniqueConstraint) {
-    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.");
-  }
-  const sortedIndexes = table.indexes.reverse().sort((a, b) => {
-    if (a.unique && !b.unique) return -1;
-    if (!a.unique && b.unique) return 1;
-    return 0;
-  });
-  sortedIndexes.forEach((index) => {
-    if (index.predicate) {
-      console.warn(colors3.yellow(`These constraints are not supported by Zenstack. Read more: https://pris.ly/d/check-constraints
-- Model: "${table.name}", constraint: "${index.name}"`));
-      return;
-    }
-    if (index.columns.find((c) => c.expression)) {
-      console.warn(colors3.yellow(`These constraints are not supported by Zenstack. Read more: https://pris.ly/d/check-constraints
-- 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;
-}
-__name(syncTable, "syncTable");
-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((ab2) => ab2.StringLiteral.setValue(relationName));
-    ab.addArg((ab2) => {
-      const arrayExpr = ab2.ArrayExpr;
-      for (const { field } of sourceFields) {
-        arrayExpr.addItem((aeb) => aeb.ReferenceExpr.setTarget(field));
-      }
-      return arrayExpr;
-    }, "fields");
-    ab.addArg((ab2) => {
-      const arrayExpr = ab2.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((ab2) => ab2.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((ab2) => ab2.StringLiteral.setValue(relationName)));
-  targetModel.fields.push(targetFieldFactory.node);
-}
-__name(syncRelation, "syncRelation");
-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)));
-    const allMatch = newEnumsGroup.every((ne) => {
-      const newValues = new Set(ne.fields.map((f) => getDbName(f)));
-      return oldValues.size === newValues.size && [
-        ...oldValues
-      ].every((v) => newValues.has(v));
-    });
-    if (!allMatch) continue;
-    keepEnum.name = oldEnum.name;
-    keepEnum.attributes = oldEnum.attributes.map((attr) => {
-      const copy = {
-        ...attr,
-        $container: keepEnum
-      };
-      return copy;
-    });
-    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(colors3.gray(`Consolidated enum${newEnumsGroup.length > 1 ? "s" : ""} ${newEnumsGroup.map((e) => e.name).join(", ")} \u2192 ${oldEnum.name}`));
-  }
-}
-__name(consolidateEnums, "consolidateEnums");
-
-// src/actions/pull/provider/mysql.ts
-import { DataFieldAttributeFactory as DataFieldAttributeFactory2 } from "@zenstackhq/language/factory";
-function normalizeGenerationExpression(typeDef) {
-  return typeDef.replace(/_([0-9A-Za-z_]+)\\?'/g, "'").replace(/\\'/g, "'");
-}
-__name(normalizeGenerationExpression, "normalizeGenerationExpression");
-var mysql = {
-  isSupportedFeature(feature) {
-    switch (feature) {
-      case "NativeEnum":
-        return true;
-      case "Schema":
-      default:
-        return false;
-    }
-  },
-  getBuiltinType(type2) {
-    const t = (type2 || "").toLowerCase().trim();
-    const isArray = false;
-    switch (t) {
-      // integers
-      case "tinyint":
-      case "smallint":
-      case "mediumint":
-      case "int":
-      case "integer":
-        return {
-          type: "Int",
-          isArray
-        };
-      case "bigint":
-        return {
-          type: "BigInt",
-          isArray
-        };
-      // decimals and floats
-      case "decimal":
-      case "numeric":
-        return {
-          type: "Decimal",
-          isArray
-        };
-      case "float":
-      case "double":
-      case "real":
-        return {
-          type: "Float",
-          isArray
-        };
-      // boolean (MySQL uses TINYINT(1) for boolean)
-      case "boolean":
-      case "bool":
-        return {
-          type: "Boolean",
-          isArray
-        };
-      // strings
-      case "char":
-      case "varchar":
-      case "tinytext":
-      case "text":
-      case "mediumtext":
-      case "longtext":
-        return {
-          type: "String",
-          isArray
-        };
-      // dates/times
-      case "date":
-      case "time":
-      case "datetime":
-      case "timestamp":
-      case "year":
-        return {
-          type: "DateTime",
-          isArray
-        };
-      // binary
-      case "binary":
-      case "varbinary":
-      case "tinyblob":
-      case "blob":
-      case "mediumblob":
-      case "longblob":
-        return {
-          type: "Bytes",
-          isArray
-        };
-      // json
-      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(type2) {
-    switch (type2) {
-      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 mysql2 = await import("mysql2/promise");
-    const connection = await mysql2.createConnection(connectionString);
-    try {
-      const url = new URL(connectionString);
-      const databaseName = url.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
-      ]);
-      const 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
-        };
-      });
-      return {
-        tables,
-        enums
-      };
-    } 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 DataFieldAttributeFactory2().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 DataFieldAttributeFactory2().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;
-`;
-}
-__name(getTableIntrospectionQuery, "getTableIntrospectionQuery");
-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;
-`;
-}
-__name(getEnumIntrospectionQuery, "getEnumIntrospectionQuery");
-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;
-}
-__name(parseEnumValues, "parseEnumValues");
-
-// src/actions/pull/provider/postgresql.ts
-import { DataFieldAttributeFactory as DataFieldAttributeFactory3 } from "@zenstackhq/language/factory";
-var pgTypnameToStandard = {
-  int2: "smallint",
-  int4: "integer",
-  int8: "bigint",
-  float4: "real",
-  float8: "double precision",
-  bool: "boolean",
-  bpchar: "character",
-  numeric: "decimal"
-};
-var standardTypePrecisions = {
-  int2: 16,
-  smallint: 16,
-  int4: 32,
-  integer: 32,
-  int8: 64,
-  bigint: 64,
-  float4: 24,
-  real: 24,
-  float8: 53,
-  "double precision": 53
-};
-var pgTypnameToZenStackNativeType = {
-  // integers
-  int2: "SmallInt",
-  smallint: "SmallInt",
-  int4: "Integer",
-  integer: "Integer",
-  int8: "BigInt",
-  bigint: "BigInt",
-  // decimals and floats
-  numeric: "Decimal",
-  decimal: "Decimal",
-  float4: "Real",
-  real: "Real",
-  float8: "DoublePrecision",
-  "double precision": "DoublePrecision",
-  // boolean
-  bool: "Boolean",
-  boolean: "Boolean",
-  // strings
-  text: "Text",
-  varchar: "VarChar",
-  "character varying": "VarChar",
-  bpchar: "Char",
-  character: "Char",
-  // uuid
-  uuid: "Uuid",
-  // dates/times
-  date: "Date",
-  time: "Time",
-  timetz: "Timetz",
-  timestamp: "Timestamp",
-  timestamptz: "Timestamptz",
-  // binary
-  bytea: "ByteA",
-  // json
-  json: "Json",
-  jsonb: "JsonB",
-  // xml
-  xml: "Xml",
-  // network types
-  inet: "Inet",
-  // bit strings
-  bit: "Bit",
-  varbit: "VarBit",
-  // oid
-  oid: "Oid",
-  // money
-  money: "Money",
-  // citext extension
-  citext: "Citext"
-};
-var postgresql = {
-  isSupportedFeature(feature) {
-    const supportedFeatures = [
-      "Schema",
-      "NativeEnum"
-    ];
-    return supportedFeatures.includes(feature);
-  },
-  getBuiltinType(type2) {
-    const t = (type2 || "").toLowerCase();
-    const isArray = t.startsWith("_");
-    switch (t.replace(/^_/, "")) {
-      // integers
-      case "int2":
-      case "smallint":
-      case "int4":
-      case "integer":
-        return {
-          type: "Int",
-          isArray
-        };
-      case "int8":
-      case "bigint":
-        return {
-          type: "BigInt",
-          isArray
-        };
-      // decimals and floats
-      case "numeric":
-      case "decimal":
-        return {
-          type: "Decimal",
-          isArray
-        };
-      case "float4":
-      case "real":
-      case "float8":
-      case "double precision":
-        return {
-          type: "Float",
-          isArray
-        };
-      // boolean
-      case "bool":
-      case "boolean":
-        return {
-          type: "Boolean",
-          isArray
-        };
-      // strings
-      case "text":
-      case "varchar":
-      case "bpchar":
-      case "character varying":
-      case "character":
-        return {
-          type: "String",
-          isArray
-        };
-      // uuid
-      case "uuid":
-        return {
-          type: "String",
-          isArray
-        };
-      // dates/times
-      case "date":
-      case "time":
-      case "timetz":
-      case "timestamp":
-      case "timestamptz":
-        return {
-          type: "DateTime",
-          isArray
-        };
-      // binary
-      case "bytea":
-        return {
-          type: "Bytes",
-          isArray
-        };
-      // json
-      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));
-      const filteredEnums = enums.filter((e) => options.schemas.includes(e.schema_name));
-      return {
-        enums: filteredEnums,
-        tables: filteredTables
-      };
-    } finally {
-      await client.end();
-    }
-  },
-  getDefaultDatabaseType(type2) {
-    switch (type2) {
-      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 DataFieldAttributeFactory3().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 DataFieldAttributeFactory3().setDecl(dbAttr);
-      if ((length || precision) && !isStandardPrecision) {
-        dbAttrFactory.addArg((a) => a.NumberLiteral.setValue(length || precision));
-      }
-      factories.push(dbAttrFactory);
-    }
-    return factories;
-  }
-};
-var 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;`;
-var 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, type2] = val.replace(/'/g, "").split("::").map((s) => s.trim());
-  switch (type2) {
-    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) === type2);
-      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 ${type2} for default value ${defaultValue}`);
-      }
-      return (ab) => ab.ReferenceExpr.setTarget(enumField);
-    }
-  }
-}
-__name(typeCastingConvert, "typeCastingConvert");
-
-// src/actions/pull/provider/sqlite.ts
-import { DataFieldAttributeFactory as DataFieldAttributeFactory4 } from "@zenstackhq/language/factory";
-var sqlite = {
-  isSupportedFeature(feature) {
-    switch (feature) {
-      case "Schema":
-        return false;
-      case "NativeEnum":
-        return false;
-      default:
-        return false;
-    }
-  },
-  getBuiltinType(type2) {
-    const t = (type2 || "").toLowerCase().trim().replace(/\(.*\)$/, "").trim();
-    const isArray = false;
-    switch (t) {
-      // INTEGER types (SQLite: INT, INTEGER, TINYINT, SMALLINT, MEDIUMINT, INT2, INT8)
-      case "integer":
-      case "int":
-      case "tinyint":
-      case "smallint":
-      case "mediumint":
-      case "int2":
-      case "int8":
-        return {
-          type: "Int",
-          isArray
-        };
-      // BIGINT - map to BigInt for large integers
-      case "bigint":
-      case "unsigned big int":
-        return {
-          type: "BigInt",
-          isArray
-        };
-      // TEXT types (SQLite: CHARACTER, VARCHAR, VARYING CHARACTER, NCHAR, NATIVE CHARACTER, NVARCHAR, TEXT, CLOB)
-      case "text":
-      case "varchar":
-      case "char":
-      case "character":
-      case "varying character":
-      case "nchar":
-      case "native character":
-      case "nvarchar":
-      case "clob":
-        return {
-          type: "String",
-          isArray
-        };
-      // BLOB type
-      case "blob":
-        return {
-          type: "Bytes",
-          isArray
-        };
-      // REAL types (SQLite: REAL, DOUBLE, DOUBLE PRECISION, FLOAT)
-      case "real":
-      case "float":
-      case "double":
-      case "double precision":
-        return {
-          type: "Float",
-          isArray
-        };
-      // NUMERIC types (SQLite: NUMERIC, DECIMAL)
-      case "numeric":
-      case "decimal":
-        return {
-          type: "Decimal",
-          isArray
-        };
-      // DateTime types
-      case "datetime":
-      case "date":
-      case "time":
-      case "timestamp":
-        return {
-          type: "DateTime",
-          isArray
-        };
-      // JSON types
-      case "json":
-      case "jsonb":
-        return {
-          type: "Json",
-          isArray
-        };
-      // Boolean types
-      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() {
-    return void 0;
-  },
-  async introspect(connectionString, _options) {
-    const SQLite = (await import("better-sqlite3")).default;
-    const db = new SQLite(connectionString, {
-      readonly: true
-    });
-    try {
-      const all = /* @__PURE__ */ __name((sql) => {
-        const stmt = db.prepare(sql);
-        return stmt.all();
-      }, "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 tableNameEsc = tableName.replace(/'/g, "''");
-        const idxList = all(`PRAGMA index_list('${tableNameEsc}')`).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 columns2 = columnList.split(",").map((col) => col.trim().replace(/^["'`]|["'`]$/g, ""));
-              for (const col of columns2) {
-                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
-        });
-      }
-      const enums = [];
-      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 DataFieldAttributeFactory4().setDecl(getAttributeRef("@updatedAt", services)));
-    }
-    return factories;
-  }
-};
-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;
-}
-__name(extractColumnTypeDefs, "extractColumnTypeDefs");
-
-// src/actions/pull/provider/index.ts
-var providers = {
-  mysql,
-  postgresql,
-  sqlite
-};
-
-// src/actions/db.ts
-async function run2(command, options) {
-  switch (command) {
-    case "push":
-      await runPush(options);
-      break;
-    case "pull":
-      await runPull(options);
-      break;
-  }
-}
-__name(run2, "run");
-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(err);
-    }
-  } finally {
-    if (fs2.existsSync(prismaSchemaFile)) {
-      fs2.unlinkSync(prismaSchemaFile);
-    }
-  }
-}
-__name(runPush, "runPush");
-async function runPull(options) {
-  const spinner = ora();
-  try {
-    const schemaFile = getSchemaFile(options.schema);
-    const outPath = options.output ? path3.resolve(options.output) : void 0;
-    const treatAsFile = !!outPath && (fs2.existsSync(outPath) && fs2.lstatSync(outPath).isFile() || path3.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(colors4.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;
-      const selfRelation = relation.references.schema === relation.schema && relation.references.table === relation.table;
-      syncRelation({
-        model: newModel,
-        relation,
-        services,
-        options,
-        selfRelation,
-        similarRelations
-      });
-    }
-    consolidateEnums({
-      newModel,
-      oldModel: model
-    });
-    console.log(colors4.blue("Schema synced"));
-    const baseDir = path3.dirname(path3.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(colors4.bold("\nApplying changes to ZModel..."));
-    const deletedModels = [];
-    const deletedEnums = [];
-    const addedModels = [];
-    const addedEnums = [];
-    const modelChanges = /* @__PURE__ */ new Map();
-    const getModelChanges = /* @__PURE__ */ __name((modelName) => {
-      if (!modelChanges.has(modelName)) {
-        modelChanges.set(modelName, {
-          addedFields: [],
-          deletedFields: [],
-          updatedFields: [],
-          addedAttributes: [],
-          deletedAttributes: [],
-          updatedAttributes: []
-        });
-      }
-      return modelChanges.get(modelName);
-    }, "getModelChanges");
-    services.shared.workspace.IndexManager.allElements("DataModel", docsSet).filter((declaration) => !newModel.declarations.find((d) => getDbName(d) === getDbName(declaration.node))).forEach((decl) => {
-      const model2 = decl.node.$container;
-      const index = model2.declarations.findIndex((d) => d === decl.node);
-      model2.declarations.splice(index, 1);
-      deletedModels.push(colors4.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 model2 = decl.node.$container;
-      const index = model2.declarations.findIndex((d) => d === decl.node);
-      model2.declarations.splice(index, 1);
-      deletedEnums.push(colors4.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(colors4.green(`+ Model ${newDataModel.name} added`));
-        } else if (newDataModel.$type === "Enum") {
-          addedEnums.push(colors4.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) {
-          const isBackReferenceField = !getRelationFieldsKey(f);
-          if (!isBackReferenceField) {
-            console.warn(colors4.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) {
-            const newRefName = getDbName(newType.reference.ref);
-            const oldRefName = getDbName(oldType.reference.ref);
-            if (newRefName !== oldRefName) {
-              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) {
-            const isEnumWithoutNativeSupport = oldType.reference.ref.$type === "Enum" && !provider.isSupportedFeature("NativeEnum");
-            if (!isEnumWithoutNativeSupport) {
-              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(colors4.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 = /* @__PURE__ */ __name((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(","), "serializeArgs");
-            const newArgsStr = serializeArgs(newDefaultAttr.args ?? []);
-            const oldArgsStr = serializeArgs(oldDefaultAttr.args ?? []);
-            if (newArgsStr !== oldArgsStr) {
-              oldDefaultAttr.args = newDefaultAttr.args.map((arg) => ({
-                ...arg,
-                $container: oldDefaultAttr
-              }));
-              getModelChanges(originalDataModel.name).updatedAttributes.push(colors4.yellow(`~ @default on ${originalDataModel.name}.${originalField.name}`));
-            }
-          }
-        }
-        if (!originalField) {
-          getModelChanges(originalDataModel.name).addedFields.push(colors4.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(colors4.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(colors4.green(`+ ${attr.decl.$refText} to field: ${originalDataModel.name}.${f.name}`));
-        });
-      });
-      originalDataModel.fields.filter((f) => {
-        const matchByDbName = newDataModel.fields.find((d) => getDbName(d) === getDbName(f));
-        if (matchByDbName) return false;
-        const originalFieldsKey = getRelationFieldsKey(f);
-        if (originalFieldsKey) {
-          const matchByFieldsKey = newDataModel.fields.find((d) => getRelationFieldsKey(d) === originalFieldsKey);
-          if (matchByFieldsKey) return false;
-        }
-        const matchByFkName = newDataModel.fields.find((d) => getRelationFkName(d) === getRelationFkName(f) && !!getRelationFkName(d) && !!getRelationFkName(f));
-        if (matchByFkName) return false;
-        const matchByTypeRef = 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));
-        return !matchByTypeRef;
-      }).forEach((f) => {
-        const _model = f.$container;
-        const index = _model.fields.findIndex((d) => d === f);
-        _model.fields.splice(index, 1);
-        getModelChanges(_model.name).deletedFields.push(colors4.red(`- ${f.name}`));
-      });
-    });
-    if (deletedModels.length > 0) {
-      console.log(colors4.bold("\nDeleted Models:"));
-      deletedModels.forEach((msg) => {
-        console.log(msg);
-      });
-    }
-    if (deletedEnums.length > 0) {
-      console.log(colors4.bold("\nDeleted Enums:"));
-      deletedEnums.forEach((msg) => {
-        console.log(msg);
-      });
-    }
-    if (addedModels.length > 0) {
-      console.log(colors4.bold("\nAdded Models:"));
-      addedModels.forEach((msg) => {
-        console.log(msg);
-      });
-    }
-    if (addedEnums.length > 0) {
-      console.log(colors4.bold("\nAdded Enums:"));
-      addedEnums.forEach((msg) => {
-        console.log(msg);
-      });
-    }
-    if (modelChanges.size > 0) {
-      console.log(colors4.bold("\nModel Changes:"));
-      modelChanges.forEach((changes, modelName) => {
-        const hasChanges = changes.addedFields.length > 0 || changes.deletedFields.length > 0 || changes.updatedFields.length > 0 || changes.addedAttributes.length > 0 || changes.deletedAttributes.length > 0 || changes.updatedAttributes.length > 0;
-        if (hasChanges) {
-          console.log(colors4.cyan(`  ${modelName}:`));
-          if (changes.addedFields.length > 0) {
-            console.log(colors4.gray("    Added Fields:"));
-            changes.addedFields.forEach((msg) => {
-              console.log(`      ${msg}`);
-            });
-          }
-          if (changes.deletedFields.length > 0) {
-            console.log(colors4.gray("    Deleted Fields:"));
-            changes.deletedFields.forEach((msg) => {
-              console.log(`      ${msg}`);
-            });
-          }
-          if (changes.updatedFields.length > 0) {
-            console.log(colors4.gray("    Updated Fields:"));
-            changes.updatedFields.forEach((msg) => {
-              console.log(`      ${msg}`);
-            });
-          }
-          if (changes.addedAttributes.length > 0) {
-            console.log(colors4.gray("    Added Attributes:"));
-            changes.addedAttributes.forEach((msg) => {
-              console.log(`      ${msg}`);
-            });
-          }
-          if (changes.deletedAttributes.length > 0) {
-            console.log(colors4.gray("    Deleted Attributes:"));
-            changes.deletedAttributes.forEach((msg) => {
-              console.log(`      ${msg}`);
-            });
-          }
-          if (changes.updatedAttributes.length > 0) {
-            console.log(colors4.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(colors4.blue(`Writing to ${outPath}`));
-        fs2.mkdirSync(path3.dirname(outPath), {
-          recursive: true
-        });
-        fs2.writeFileSync(outPath, zmodelSchema);
-      } else {
-        fs2.mkdirSync(outPath, {
-          recursive: true
-        });
-        const baseDir2 = path3.dirname(path3.resolve(schemaFile));
-        for (const { uri, parseResult: { value: documentModel } } of docs) {
-          const zmodelSchema = await formatDocument(generator.generate(documentModel));
-          const relPath = path3.relative(baseDir2, uri.fsPath);
-          const targetFile = path3.join(outPath, relPath);
-          fs2.mkdirSync(path3.dirname(targetFile), {
-            recursive: true
-          });
-          console.log(colors4.blue(`Writing to ${targetFile}`));
-          fs2.writeFileSync(targetFile, zmodelSchema);
-        }
-      }
-    } else {
-      for (const { uri, parseResult: { value: documentModel } } of docs) {
-        const zmodelSchema = await formatDocument(generator.generate(documentModel));
-        console.log(colors4.blue(`Writing to ${path3.relative(process.cwd(), uri.fsPath).replace(/\\/g, "/")}`));
-        fs2.writeFileSync(uri.fsPath, zmodelSchema);
-      }
-    }
-    console.log(colors4.green.bold("\nPull completed successfully!"));
-  } catch (error) {
-    spinner.fail("Pull failed");
-    console.error(error);
-    throw error;
-  }
-}
-__name(runPull, "runPull");
-
-// src/actions/format.ts
-import { formatDocument as formatDocument2 } from "@zenstackhq/language";
-import colors5 from "colors";
-import fs3 from "fs";
-async function run3(options) {
-  const schemaFile = getSchemaFile(options.schema);
-  let formattedContent;
-  try {
-    formattedContent = await formatDocument2(fs3.readFileSync(schemaFile, "utf-8"));
-  } catch (error) {
-    console.error(colors5.red("\u2717 Schema formatting failed."));
-    throw error;
-  }
-  fs3.writeFileSync(schemaFile, formattedContent, "utf-8");
-  console.log(colors5.green("\u2713 Schema formatting completed successfully."));
-}
-__name(run3, "run");
-
-// src/actions/generate.ts
-import { invariant as invariant2, singleDebounce } from "@zenstackhq/common-helpers";
-import { ZModelLanguageMetaData } from "@zenstackhq/language";
-import { isPlugin as isPlugin2 } from "@zenstackhq/language/ast";
-import { getLiteral, getLiteralArray as getLiteralArray2 } from "@zenstackhq/language/utils";
-import { watch } from "chokidar";
-import colors6 from "colors";
-import path6 from "path";
-import ora2 from "ora";
-import semver from "semver";
-
-// src/plugins/index.ts
-var plugins_exports = {};
-__export(plugins_exports, {
-  prisma: () => prisma_default,
-  typescript: () => typescript_default
-});
-
-// src/plugins/prisma.ts
-import { PrismaSchemaGenerator as PrismaSchemaGenerator2 } from "@zenstackhq/sdk";
-import fs4 from "fs";
-import path4 from "path";
-var plugin = {
-  name: "Prisma Schema Generator",
-  statusText: "Generating Prisma schema",
-  async generate({ model, defaultOutputPath, pluginOptions }) {
-    let outFile = path4.join(defaultOutputPath, "schema.prisma");
-    if (typeof pluginOptions["output"] === "string") {
-      outFile = path4.resolve(defaultOutputPath, pluginOptions["output"]);
-      if (!fs4.existsSync(path4.dirname(outFile))) {
-        fs4.mkdirSync(path4.dirname(outFile), {
-          recursive: true
-        });
-      }
-    }
-    const prismaSchema = await new PrismaSchemaGenerator2(model).generate();
-    fs4.writeFileSync(outFile, prismaSchema);
-  }
-};
-var prisma_default = plugin;
-
-// src/plugins/typescript.ts
-import { TsSchemaGenerator } from "@zenstackhq/sdk";
-import fs5 from "fs";
-import path5 from "path";
-var plugin2 = {
-  name: "TypeScript Schema Generator",
-  statusText: "Generating TypeScript schema",
-  async generate({ model, defaultOutputPath, pluginOptions }) {
-    let outDir = defaultOutputPath;
-    if (typeof pluginOptions["output"] === "string") {
-      outDir = path5.resolve(defaultOutputPath, pluginOptions["output"]);
-      if (!fs5.existsSync(outDir)) {
-        fs5.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
-    });
-  }
-};
-var typescript_default = plugin2;
-
-// src/actions/generate.ts
-async function run4(options) {
-  try {
-    await checkForMismatchedPackages(process.cwd());
-  } catch (err) {
-    console.warn(colors6.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(colors6.green(`
-Enabled watch mode!`));
-    }
-    const schemaExtensions = ZModelLanguageMetaData.fileExtensions;
-    const getRootModelWatchPaths = /* @__PURE__ */ __name((model2) => new Set(model2.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)), "getRootModelWatchPaths");
-    const watchedPaths = getRootModelWatchPaths(model);
-    if (logsEnabled) {
-      const logPaths = [
-        ...watchedPaths
-      ].map((at) => `- ${at}`).join("\n");
-      console.log(`Watched file paths:
-${logPaths}`);
-    }
-    const watcher = watch([
-      ...watchedPaths
-    ], {
-      alwaysStat: false,
-      ignoreInitial: true,
-      ignorePermissionErrors: true,
-      ignored: /* @__PURE__ */ __name((at) => !schemaExtensions.some((ext) => at.endsWith(ext)), "ignored")
-    });
-    const reGenerateSchema = singleDebounce(async () => {
-      if (logsEnabled) {
-        console.log("Got changes, run generation!");
-      }
-      try {
-        const newModel = await pureGenerate(options, true);
-        const allModelsPaths = getRootModelWatchPaths(newModel);
-        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:
-${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:
-${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();
-    });
-  }
-}
-__name(run4, "run");
-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(colors6.green(`Generation completed successfully in ${Date.now() - start}ms.
-`));
-    if (!fromWatch) {
-      console.log(`You can now create a ZenStack client with it.
-
-\`\`\`ts
-import { ZenStackClient } from '@zenstackhq/orm';
-import { schema } from '${path6.relative(".", outputPath)}/schema';
-
-const client = new ZenStackClient(schema, {
-    dialect: { ... }
-});
-\`\`\`
-
-Check documentation: https://zenstack.dev/docs/`);
-    }
-  }
-  return model;
-}
-__name(pureGenerate, "pureGenerate");
-async function runPlugins(schemaFile, model, outputPath, options) {
-  const plugins = model.declarations.filter(isPlugin2);
-  const processedPlugins = [];
-  for (const plugin3 of plugins) {
-    const provider = getPluginProvider(plugin3);
-    let cliPlugin;
-    if (provider.startsWith("@core/")) {
-      cliPlugin = plugins_exports[provider.slice("@core/".length)];
-      if (!cliPlugin) {
-        throw new CliError(`Unknown core plugin: ${provider}`);
-      }
-    } else {
-      const pluginSourcePath = plugin3.$cstNode?.parent?.element.$document?.uri?.fsPath ?? schemaFile;
-      cliPlugin = await loadPluginModule(provider, path6.dirname(pluginSourcePath));
-    }
-    if (cliPlugin) {
-      const pluginOptions = getPluginOptions(plugin3);
-      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
-      });
-    }
-  }
-  const defaultPlugins = [
-    {
-      plugin: typescript_default,
-      options: {
-        lite: options.lite,
-        liteOnly: options.liteOnly,
-        generateModels: options.generateModels,
-        generateInput: options.generateInput
-      }
-    }
-  ];
-  defaultPlugins.forEach(({ plugin: plugin3, options: options2 }) => {
-    if (!processedPlugins.some((p) => p.cliPlugin === plugin3)) {
-      processedPlugins.unshift({
-        cliPlugin: plugin3,
-        pluginOptions: options2
-      });
-    }
-  });
-  for (const { cliPlugin, pluginOptions } of processedPlugins) {
-    invariant2(typeof cliPlugin.generate === "function", `Plugin ${cliPlugin.name} does not have a generate function`);
-    let spinner;
-    if (!options.silent) {
-      spinner = ora2(cliPlugin.statusText ?? `Running plugin ${cliPlugin.name}`).start();
-    }
-    try {
-      await cliPlugin.generate({
-        schemaFile,
-        model,
-        defaultOutputPath: outputPath,
-        pluginOptions
-      });
-      spinner?.succeed();
-    } catch (err) {
-      spinner?.fail();
-      throw err;
-    }
-  }
-}
-__name(runPlugins, "runPlugins");
-function getPluginOptions(plugin3) {
-  const result = {};
-  for (const field of plugin3.fields) {
-    if (field.name === "provider") {
-      continue;
-    }
-    const value = getLiteral(field.value) ?? getLiteralArray2(field.value);
-    if (value === void 0) {
-      console.warn(`Plugin "${plugin3.name}" option "${field.name}" has unsupported value, skipping`);
-      continue;
-    }
-    result[field.name] = value;
-  }
-  return result;
-}
-__name(getPluginOptions, "getPluginOptions");
-async function checkForMismatchedPackages(projectPath) {
-  const packages = await getZenStackPackages(projectPath);
-  if (!packages.length) {
-    return false;
-  }
-  const versions = /* @__PURE__ */ new Set();
-  for (const { version: version2 } of packages) {
-    if (version2) {
-      versions.add(version2);
-    }
-  }
-  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(colors6.yellow(`${slashes}
-
-	${message}
-`));
-    for (const { pkg, version: version2 } of packages) {
-      if (!version2) continue;
-      if (version2 === latestVersion) {
-        console.log(`	${pkg.padEnd(32)}	${colors6.green(version2)}`);
-      } else {
-        console.log(`	${pkg.padEnd(32)}	${colors6.yellow(version2)}`);
-      }
-    }
-    console.warn(`
-${colors6.yellow(slashes)}`);
-    return true;
-  }
-  return false;
-}
-__name(checkForMismatchedPackages, "checkForMismatchedPackages");
-
-// src/actions/info.ts
-import colors7 from "colors";
-async function run5(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: version2 } of packages) {
-    if (version2) {
-      versions.add(version2);
-    }
-    console.log(`    ${colors7.green(pkg.padEnd(20))}	${version2}`);
-  }
-  if (versions.size > 1) {
-    console.warn(colors7.yellow("WARNING: Multiple versions of Zenstack packages detected. This may cause issues."));
-  }
-}
-__name(run5, "run");
-
-// src/actions/init.ts
-import colors8 from "colors";
-import fs6 from "fs";
-import path7 from "path";
-import ora3 from "ora";
-import { detect, resolveCommand } from "package-manager-detector";
-
-// src/actions/templates.ts
-var 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
-}
-`;
-
-// src/actions/init.ts
-async function run6(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(colors8.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 = ora3(`Installing "${pkg.name}"`).start();
-    try {
-      execSync(`${resolved.command} ${resolved.args.join(" ")}`, {
-        cwd: projectPath
-      });
-      spinner.succeed();
-    } catch (e) {
-      spinner.fail();
-      throw e;
-    }
-  }
-  const generationFolder = "zenstack";
-  if (!fs6.existsSync(path7.join(projectPath, generationFolder))) {
-    fs6.mkdirSync(path7.join(projectPath, generationFolder));
-  }
-  if (!fs6.existsSync(path7.join(projectPath, generationFolder, "schema.zmodel"))) {
-    fs6.writeFileSync(path7.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
-  } else {
-    console.log(colors8.yellow("Schema file already exists. Skipping generation of sample."));
-  }
-  console.log(colors8.green("ZenStack project initialized successfully!"));
-  console.log(colors8.gray(`See "${generationFolder}/schema.zmodel" for your database schema.`));
-  console.log(colors8.gray("Run `zenstack generate` to compile the the schema into a TypeScript file."));
-}
-__name(run6, "run");
-
-// src/actions/migrate.ts
-import fs7 from "fs";
-import path8 from "path";
-
-// src/actions/seed.ts
-import colors9 from "colors";
-import { execaCommand } from "execa";
-async function run7(options, args) {
-  const pkgJsonConfig = getPkgJsonConfig(process.cwd());
-  if (!pkgJsonConfig.seed) {
-    if (!options.noWarnings) {
-      console.warn(colors9.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(colors9.gray(`Running seed script "${command}"...`));
-  }
-  try {
-    await execaCommand(command, {
-      stdout: "inherit",
-      stderr: "inherit"
-    });
-  } catch (err) {
-    console.error(colors9.red(err instanceof Error ? err.message : String(err)));
-    throw new CliError("Failed to seed the database. Please check the error message above for details.");
-  }
-}
-__name(run7, "run");
-
-// src/actions/migrate.ts
-async function run8(command, options) {
-  const schemaFile = getSchemaFile(options.schema);
-  await requireDataSourceUrl(schemaFile);
-  const prismaSchemaDir = options.migrations ? path8.dirname(options.migrations) : void 0;
-  const prismaSchemaFile = await generateTempPrismaSchema(schemaFile, prismaSchemaDir);
-  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 (fs7.existsSync(prismaSchemaFile)) {
-      fs7.unlinkSync(prismaSchemaFile);
-    }
-  }
-}
-__name(run8, "run");
-function runDev(prismaSchemaFile, options) {
-  try {
-    const cmd = [
-      "migrate dev",
-      ` --schema "${prismaSchemaFile}"`,
-      " --skip-generate",
-      " --skip-seed",
-      options.name ? ` --name "${options.name}"` : "",
-      options.createOnly ? " --create-only" : ""
-    ].join("");
-    execPrisma(cmd);
-  } catch (err) {
-    handleSubProcessError2(err);
-  }
-}
-__name(runDev, "runDev");
-async function runReset(prismaSchemaFile, options) {
-  try {
-    const cmd = [
-      "migrate reset",
-      ` --schema "${prismaSchemaFile}"`,
-      " --skip-generate",
-      " --skip-seed",
-      options.force ? " --force" : ""
-    ].join("");
-    execPrisma(cmd);
-  } catch (err) {
-    handleSubProcessError2(err);
-  }
-  if (!options.skipSeed) {
-    await run7({
-      noWarnings: true,
-      printStatus: true
-    }, []);
-  }
-}
-__name(runReset, "runReset");
-function runDeploy(prismaSchemaFile, _options) {
-  try {
-    const cmd = [
-      "migrate deploy",
-      ` --schema "${prismaSchemaFile}"`
-    ].join("");
-    execPrisma(cmd);
-  } catch (err) {
-    handleSubProcessError2(err);
-  }
-}
-__name(runDeploy, "runDeploy");
-function runStatus(prismaSchemaFile, _options) {
-  try {
-    execPrisma(`migrate status --schema "${prismaSchemaFile}"`);
-  } catch (err) {
-    handleSubProcessError2(err);
-  }
-}
-__name(runStatus, "runStatus");
-function runResolve(prismaSchemaFile, options) {
-  if (!options.applied && !options.rolledBack) {
-    throw new CliError("Either --applied or --rolled-back option must be provided");
-  }
-  try {
-    const cmd = [
-      "migrate resolve",
-      ` --schema "${prismaSchemaFile}"`,
-      options.applied ? ` --applied "${options.applied}"` : "",
-      options.rolledBack ? ` --rolled-back "${options.rolledBack}"` : ""
-    ].join("");
-    execPrisma(cmd);
-  } catch (err) {
-    handleSubProcessError2(err);
-  }
-}
-__name(runResolve, "runResolve");
-function handleSubProcessError2(err) {
-  if (err instanceof Error && "status" in err && typeof err.status === "number") {
-    process.exit(err.status);
-  } else {
-    process.exit(1);
-  }
-}
-__name(handleSubProcessError2, "handleSubProcessError");
-
-// src/actions/proxy.ts
-import { isDataSource as isDataSource2, isInvocationExpr as isInvocationExpr2, isLiteralExpr } from "@zenstackhq/language/ast";
-import { getStringLiteral as getStringLiteral2 } from "@zenstackhq/language/utils";
-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 colors11 from "colors";
-import cors from "cors";
-import express from "express";
-import { createJiti as createJiti2 } from "jiti";
-import path10 from "path";
-
-// src/utils/version-utils.ts
-import colors10 from "colors";
-import fs8 from "fs";
-import path9 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import semver2 from "semver";
-var CHECK_VERSION_TIMEOUT = 2e3;
-var VERSION_CHECK_TAG = "latest";
-function getVersion() {
-  try {
-    const _dirname = typeof __dirname !== "undefined" ? __dirname : path9.dirname(fileURLToPath2(import.meta.url));
-    return JSON.parse(fs8.readFileSync(path9.join(_dirname, "../package.json"), "utf8")).version;
-  } catch {
-    return void 0;
-  }
-}
-__name(getVersion, "getVersion");
-async function checkNewVersion() {
-  const currVersion = getVersion();
-  let latestVersion;
-  try {
-    latestVersion = await getLatestVersion();
-  } catch {
-    return;
-  }
-  if (latestVersion && currVersion && semver2.gt(latestVersion, currVersion)) {
-    console.log(`A newer version ${colors10.cyan(latestVersion)} is available.`);
-  }
-}
-__name(checkNewVersion, "checkNewVersion");
-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 data = await fetchResult.json();
-    const latestVersion = data?.version;
-    if (typeof latestVersion === "string" && semver2.valid(latestVersion)) {
-      return latestVersion;
-    }
-  }
-  throw new Error("invalid npm registry response");
-}
-__name(getLatestVersion, "getLatestVersion");
-
-// src/actions/proxy.ts
-async function run9(options) {
-  const allowedLogLevels = [
-    "error",
-    "query"
-  ];
-  const log = options.logLevel?.filter((level) => allowedLogLevels.includes(level));
-  const schemaFile = getSchemaFile(options.schema);
-  console.log(colors11.gray(`Loading ZModel schema from: ${schemaFile}`));
-  let outputPath = getOutputPath(options, schemaFile);
-  if (!path10.isAbsolute(outputPath)) {
-    outputPath = path10.resolve(process.cwd(), outputPath);
-  }
-  const model = await loadSchemaDocument(schemaFile);
-  const dataSource = model.declarations.find(isDataSource2);
-  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 provider = getStringLiteral2(dataSource?.fields.find((f) => f.name === "provider")?.value);
-  const dialect = await createDialect(provider, databaseUrl, outputPath);
-  const fileUrl = typeof __filename !== "undefined" ? __filename : import.meta.url;
-  const jiti = createJiti2(fileUrl);
-  const schemaModule = await jiti.import(path10.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);
-}
-__name(run9, "run");
-function evaluateUrl(schemaUrl) {
-  if (isLiteralExpr(schemaUrl)) {
-    return getStringLiteral2(schemaUrl);
-  } else if (isInvocationExpr2(schemaUrl)) {
-    const envFunction = schemaUrl;
-    const envName = getStringLiteral2(envFunction.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.`);
-  }
-}
-__name(evaluateUrl, "evaluateUrl");
-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;
-  }
-}
-__name(redactDatabaseUrl, "redactDatabaseUrl");
-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("file:".length);
-        if (!path10.isAbsolute(filePath)) {
-          resolvedUrl = path10.join(outputPath, filePath);
-        }
-      }
-      console.log(colors11.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(colors11.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(colors11.gray(`Connecting to MySQL database at: ${redactDatabaseUrl(databaseUrl)}`));
-      return new MysqlDialect({
-        pool: createMysqlPool(databaseUrl)
-      });
-    }
-    default:
-      throw new CliError(`Unsupported database provider: ${provider}`);
-  }
-}
-__name(createDialect, "createDialect");
-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: /* @__PURE__ */ __name(() => client, "getClient")
-  }));
-  app.get("/api/schema", (_req, res) => {
-    res.json({
-      ...schema,
-      zenstackVersion: getVersion()
-    });
-  });
-  return app;
-}
-__name(createProxyApp, "createProxyApp");
-function startServer(client, schema, options) {
-  const app = createProxyApp(client, schema);
-  const server = app.listen(options.port, () => {
-    console.log(`ZenStack proxy server is running on port: ${options.port}`);
-    console.log(`You can visit ZenStack Studio at: ${colors11.blue("https://studio.zenstack.dev")}`);
-  });
-  server.on("error", (err) => {
-    if (err.code === "EADDRINUSE") {
-      console.error(colors11.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);
-  });
-}
-__name(startServer, "startServer");
-
-// src/telemetry.ts
-import { init } from "mixpanel";
-import { randomUUID as randomUUID2 } from "crypto";
-import fs12 from "fs";
-import * as os2 from "os";
-
-// src/constants.ts
-var TELEMETRY_TRACKING_TOKEN = "74944eb779d7d3b4ce185be843fde9fc";
-
-// src/utils/is-ci.ts
-import { env } from "process";
-var isInCi = env["CI"] !== "0" && env["CI"] !== "false" && ("CI" in env || "CONTINUOUS_INTEGRATION" in env || Object.keys(env).some((key) => key.startsWith("CI_")));
-
-// src/utils/is-container.ts
-import fs10 from "fs";
-
-// src/utils/is-docker.ts
-import fs9 from "fs";
-var isDockerCached;
-function hasDockerEnv() {
-  try {
-    fs9.statSync("/.dockerenv");
-    return true;
-  } catch {
-    return false;
-  }
-}
-__name(hasDockerEnv, "hasDockerEnv");
-function hasDockerCGroup() {
-  try {
-    return fs9.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
-  } catch {
-    return false;
-  }
-}
-__name(hasDockerCGroup, "hasDockerCGroup");
-function isDocker() {
-  if (isDockerCached === void 0) {
-    isDockerCached = hasDockerEnv() || hasDockerCGroup();
-  }
-  return isDockerCached;
-}
-__name(isDocker, "isDocker");
-
-// src/utils/is-container.ts
-var cachedResult;
-var hasContainerEnv = /* @__PURE__ */ __name(() => {
-  try {
-    fs10.statSync("/run/.containerenv");
-    return true;
-  } catch {
-    return false;
-  }
-}, "hasContainerEnv");
-function isInContainer() {
-  if (cachedResult === void 0) {
-    cachedResult = hasContainerEnv() || isDocker();
-  }
-  return cachedResult;
-}
-__name(isInContainer, "isInContainer");
-
-// src/utils/is-wsl.ts
-import process2 from "process";
-import os from "os";
-import fs11 from "fs";
-var isWsl = /* @__PURE__ */ __name(() => {
-  if (process2.platform !== "linux") {
-    return false;
-  }
-  if (os.release().toLowerCase().includes("microsoft")) {
-    return true;
-  }
-  try {
-    return fs11.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
-  } catch {
-    return false;
-  }
-}, "isWsl");
-
-// src/utils/machine-id-utils.ts
-import { execSync as execSync2 } from "child_process";
-import { createHash, randomUUID } from "crypto";
-var { platform } = process;
-var win32RegBinPath = {
-  native: "%windir%\\System32",
-  mixed: "%windir%\\sysnative\\cmd.exe /c %windir%\\System32"
-};
-var guid = {
-  darwin: "ioreg -rd1 -c IOPlatformExpertDevice",
-  win32: `${win32RegBinPath[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";
-}
-__name(isWindowsProcessMixedOrNativeArchitecture, "isWindowsProcessMixedOrNativeArchitecture");
-function hash(guid2) {
-  return createHash("sha256").update(guid2).digest("hex");
-}
-__name(hash, "hash");
-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}`);
-  }
-}
-__name(expose, "expose");
-function getMachineId() {
-  if (!(platform in guid)) {
-    return randomUUID();
-  }
-  try {
-    const value = execSync2(guid[platform]);
-    const id = expose(value.toString());
-    if (!id) {
-      return randomUUID();
-    }
-    return hash(id);
-  } catch {
-    return randomUUID();
-  }
-}
-__name(getMachineId, "getMachineId");
-
-// src/telemetry.ts
-var Telemetry = class {
-  static {
-    __name(this, "Telemetry");
-  }
-  mixpanel;
-  hostId = getMachineId();
-  sessionid = randomUUID2();
-  _os_type = os2.type();
-  _os_release = os2.release();
-  _os_arch = os2.arch();
-  _os_version = os2.version();
-  _os_platform = os2.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);
-      const packageJson = JSON.parse(fs12.readFileSync(packageJsonUrl, "utf8"));
-      return packageJson.version;
-    } catch {
-      return void 0;
-    }
-  }
-};
-var telemetry = new Telemetry();
-
-// src/index.ts
-var generateAction = /* @__PURE__ */ __name(async (options) => {
-  await telemetry.trackCommand("generate", () => run4(options));
-}, "generateAction");
-var migrateAction = /* @__PURE__ */ __name(async (subCommand, options) => {
-  await telemetry.trackCommand(`migrate ${subCommand}`, () => run8(subCommand, options));
-}, "migrateAction");
-var dbAction = /* @__PURE__ */ __name(async (subCommand, options) => {
-  await telemetry.trackCommand(`db ${subCommand}`, () => run2(subCommand, options));
-}, "dbAction");
-var infoAction = /* @__PURE__ */ __name(async (projectPath) => {
-  await telemetry.trackCommand("info", () => run5(projectPath));
-}, "infoAction");
-var initAction = /* @__PURE__ */ __name(async (projectPath) => {
-  await telemetry.trackCommand("init", () => run6(projectPath));
-}, "initAction");
-var checkAction = /* @__PURE__ */ __name(async (options) => {
-  await telemetry.trackCommand("check", () => run(options));
-}, "checkAction");
-var formatAction = /* @__PURE__ */ __name(async (options) => {
-  await telemetry.trackCommand("format", () => run3(options));
-}, "formatAction");
-var seedAction = /* @__PURE__ */ __name(async (options, args) => {
-  await telemetry.trackCommand("db seed", () => run7(options, args));
-}, "seedAction");
-var proxyAction = /* @__PURE__ */ __name(async (options) => {
-  await telemetry.trackCommand("proxy", () => run9(options));
-}, "proxyAction");
-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}`);
-  });
-}
-__name(triStateBooleanOption, "triStateBooleanOption");
-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 = ZModelLanguageMetaData2.fileExtensions.join(", ");
-  program.description(`${colors12.bold.blue("\u03B6")} ZenStack is the modern data layer for TypeScript apps.
-
-Documentation: 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;
-}
-__name(createProgram, "createProgram");
-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(colors12.red(e.message));
-      exitCode = 1;
-    } else {
-      console.error(colors12.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);
-  }
-}
-__name(main, "main");
-main();
-//# sourceMappingURL=index.js.map