@zenstackhq/cli 3.3.3 → 3.4.0-beta.2

package/dist/index.js

@@ -14,7 +14,7 @@ var __export = (target, all) => {
 // src/index.ts
 import "dotenv/config";
 import { ZModelLanguageMetaData as ZModelLanguageMetaData2 } from "@zenstackhq/language";
-import colors10 from "colors";
+import colors12 from "colors";
 import { Command, CommanderError, Option } from "commander";
 
 // src/actions/check.ts
@@ -26,6 +26,7 @@ import { isDataSource } from "@zenstackhq/language/ast";
 import { PrismaSchemaGenerator } from "@zenstackhq/sdk";
 import colors from "colors";
 import fs from "fs";
+import { createRequire } from "module";
 import path from "path";
 
 // src/cli-error.ts
@@ -67,8 +68,10 @@ function getSchemaFile(file) {
   }
 }
 __name(getSchemaFile, "getSchemaFile");
-async function loadSchemaDocument(schemaFile) {
-  const loadResult = await loadDocument(schemaFile);
+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));
@@ -78,6 +81,10 @@ async function loadSchemaDocument(schemaFile) {
   loadResult.warnings.forEach((warn) => {
     console.warn(colors.yellow(warn));
   });
+  if (returnServices) return {
+    model: loadResult.model,
+    services: loadResult.services
+  };
   return loadResult.model;
 }
 __name(loadSchemaDocument, "loadSchemaDocument");
@@ -135,10 +142,10 @@ function findUp(names, cwd = process.cwd(), multiple = false, result = []) {
   }
   const target = names.find((name) => fs.existsSync(path.join(cwd, name)));
   if (multiple === false && target) {
-    return path.join(cwd, target);
+    return path.resolve(cwd, target);
   }
   if (target) {
-    result.push(path.join(cwd, target));
+    result.push(path.resolve(cwd, target));
   }
   const up = path.resolve(cwd, "..");
   if (up === cwd) {
@@ -167,6 +174,44 @@ function getOutputPath(options, 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");
 
 // src/actions/check.ts
 async function run(options) {
@@ -182,7 +227,12 @@ async function run(options) {
 __name(run, "run");
 
 // 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 path2 from "path";
+import ora from "ora";
 
 // src/utils/exec-utils.ts
 import { execSync as _exec } from "child_process";
@@ -231,12 +281,2156 @@ function execPrisma(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";
+import { Client } from "pg";
+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 = 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 SQLite2 = (await import("better-sqlite3")).default;
+    const db = new SQLite2(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_%' 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");
@@ -264,22 +2458,421 @@ async function runPush(options) {
   }
 }
 __name(runPush, "runPush");
+async function runPull(options) {
+  const spinner = ora();
+  try {
+    const schemaFile = getSchemaFile(options.schema);
+    const outPath = options.output ? path2.resolve(options.output) : void 0;
+    const treatAsFile = !!outPath && (fs2.existsSync(outPath) && fs2.lstatSync(outPath).isFile() || path2.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 = path2.dirname(path2.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(path2.dirname(outPath), {
+          recursive: true
+        });
+        fs2.writeFileSync(outPath, zmodelSchema);
+      } else {
+        fs2.mkdirSync(outPath, {
+          recursive: true
+        });
+        const baseDir2 = path2.dirname(path2.resolve(schemaFile));
+        for (const { uri, parseResult: { value: documentModel } } of docs) {
+          const zmodelSchema = await formatDocument(generator.generate(documentModel));
+          const relPath = path2.relative(baseDir2, uri.fsPath);
+          const targetFile = path2.join(outPath, relPath);
+          fs2.mkdirSync(path2.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 ${path2.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 } from "@zenstackhq/language";
-import colors3 from "colors";
+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 formatDocument(fs3.readFileSync(schemaFile, "utf-8"));
+    formattedContent = await formatDocument2(fs3.readFileSync(schemaFile, "utf-8"));
   } catch (error) {
-    console.error(colors3.red("\u2717 Schema formatting failed."));
+    console.error(colors5.red("\u2717 Schema formatting failed."));
     throw error;
   }
   fs3.writeFileSync(schemaFile, formattedContent, "utf-8");
-  console.log(colors3.green("\u2713 Schema formatting completed successfully."));
+  console.log(colors5.green("\u2713 Schema formatting completed successfully."));
 }
 __name(run3, "run");
 
@@ -287,14 +2880,14 @@ __name(run3, "run");
 import { invariant, singleDebounce } from "@zenstackhq/common-helpers";
 import { ZModelLanguageMetaData } from "@zenstackhq/language";
 import { isPlugin } from "@zenstackhq/language/ast";
-import { getLiteral, getLiteralArray } from "@zenstackhq/language/utils";
-import colors4 from "colors";
+import { getLiteral, getLiteralArray as getLiteralArray2 } from "@zenstackhq/language/utils";
+import colors6 from "colors";
 import { createJiti } from "jiti";
 import fs6 from "fs";
-import path4 from "path";
+import path5 from "path";
 import { pathToFileURL } from "url";
 import { watch } from "chokidar";
-import ora from "ora";
+import ora2 from "ora";
 
 // src/plugins/index.ts
 var plugins_exports = {};
@@ -306,16 +2899,16 @@ __export(plugins_exports, {
 // src/plugins/prisma.ts
 import { PrismaSchemaGenerator as PrismaSchemaGenerator2 } from "@zenstackhq/sdk";
 import fs4 from "fs";
-import path2 from "path";
+import path3 from "path";
 var plugin = {
   name: "Prisma Schema Generator",
   statusText: "Generating Prisma schema",
   async generate({ model, defaultOutputPath, pluginOptions }) {
-    let outFile = path2.join(defaultOutputPath, "schema.prisma");
+    let outFile = path3.join(defaultOutputPath, "schema.prisma");
     if (typeof pluginOptions["output"] === "string") {
-      outFile = path2.resolve(defaultOutputPath, pluginOptions["output"]);
-      if (!fs4.existsSync(path2.dirname(outFile))) {
-        fs4.mkdirSync(path2.dirname(outFile), {
+      outFile = path3.resolve(defaultOutputPath, pluginOptions["output"]);
+      if (!fs4.existsSync(path3.dirname(outFile))) {
+        fs4.mkdirSync(path3.dirname(outFile), {
           recursive: true
         });
       }
@@ -329,14 +2922,14 @@ var prisma_default = plugin;
 // src/plugins/typescript.ts
 import { TsSchemaGenerator } from "@zenstackhq/sdk";
 import fs5 from "fs";
-import path3 from "path";
+import path4 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 = path3.resolve(defaultOutputPath, pluginOptions["output"]);
+      outDir = path4.resolve(defaultOutputPath, pluginOptions["output"]);
       if (!fs5.existsSync(outDir)) {
         fs5.mkdirSync(outDir, {
           recursive: true
@@ -360,12 +2953,18 @@ var plugin2 = {
 var typescript_default = plugin2;
 
 // src/actions/generate.ts
+import semver from "semver";
 async function run4(options) {
+  try {
+    await checkForMismatchedPackages(process.cwd());
+  } catch (err) {
+    console.warn(colors6.yellow(`Failed to check for mismatched ZenStack packages: ${err}`));
+  }
   const model = await pureGenerate(options, false);
   if (options.watch) {
     const logsEnabled = !options.silent;
     if (logsEnabled) {
-      console.log(colors4.green(`
+      console.log(colors6.green(`
 Enabled watch mode!`));
     }
     const schemaExtensions = ZModelLanguageMetaData.fileExtensions;
@@ -442,14 +3041,14 @@ async function pureGenerate(options, fromWatch) {
   const outputPath = getOutputPath(options, schemaFile);
   await runPlugins(schemaFile, model, outputPath, options);
   if (!options.silent) {
-    console.log(colors4.green(`Generation completed successfully in ${Date.now() - start}ms.
+    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 '${path4.relative(".", outputPath)}/schema';
+import { schema } from '${path5.relative(".", outputPath)}/schema';
 
 const client = new ZenStackClient(schema, {
     dialect: { ... }
@@ -474,7 +3073,7 @@ async function runPlugins(schemaFile, model, outputPath, options) {
         throw new CliError(`Unknown core plugin: ${provider}`);
       }
     } else {
-      cliPlugin = await loadPluginModule(provider, path4.dirname(schemaFile));
+      cliPlugin = await loadPluginModule(provider, path5.dirname(schemaFile));
     }
     if (cliPlugin) {
       const pluginOptions = getPluginOptions(plugin3);
@@ -513,7 +3112,7 @@ async function runPlugins(schemaFile, model, outputPath, options) {
     invariant(typeof cliPlugin.generate === "function", `Plugin ${cliPlugin.name} does not have a generate function`);
     let spinner;
     if (!options.silent) {
-      spinner = ora(cliPlugin.statusText ?? `Running plugin ${cliPlugin.name}`).start();
+      spinner = ora2(cliPlugin.statusText ?? `Running plugin ${cliPlugin.name}`).start();
     }
     try {
       await cliPlugin.generate({
@@ -543,7 +3142,7 @@ function getPluginOptions(plugin3) {
     if (field.name === "provider") {
       continue;
     }
-    const value = getLiteral(field.value) ?? getLiteralArray(field.value);
+    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;
@@ -556,7 +3155,7 @@ __name(getPluginOptions, "getPluginOptions");
 async function loadPluginModule(provider, basePath) {
   let moduleSpec = provider;
   if (moduleSpec.startsWith(".")) {
-    moduleSpec = path4.resolve(basePath, moduleSpec);
+    moduleSpec = path5.resolve(basePath, moduleSpec);
   }
   const importAsEsm = /* @__PURE__ */ __name(async (spec) => {
     try {
@@ -594,13 +3193,13 @@ async function loadPluginModule(provider, basePath) {
     }
   }
   for (const suffix of esmSuffixes) {
-    const indexPath = path4.join(moduleSpec, `index${suffix}`);
+    const indexPath = path5.join(moduleSpec, `index${suffix}`);
     if (fs6.existsSync(indexPath)) {
       return await importAsEsm(pathToFileURL(indexPath).toString());
     }
   }
   for (const suffix of tsSuffixes) {
-    const indexPath = path4.join(moduleSpec, `index${suffix}`);
+    const indexPath = path5.join(moduleSpec, `index${suffix}`);
     if (fs6.existsSync(indexPath)) {
       return await importAsTs(indexPath);
     }
@@ -612,13 +3211,46 @@ async function loadPluginModule(provider, basePath) {
   }
 }
 __name(loadPluginModule, "loadPluginModule");
+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 colors5 from "colors";
-import path5 from "path";
+import colors7 from "colors";
 async function run5(projectPath) {
   const packages = await getZenStackPackages(projectPath);
-  if (!packages) {
+  if (!packages.length) {
     console.error("Unable to locate package.json. Are you in a valid project directory?");
     return;
   }
@@ -628,59 +3260,19 @@ async function run5(projectPath) {
     if (version2) {
       versions.add(version2);
     }
-    console.log(`    ${colors5.green(pkg.padEnd(20))}	${version2}`);
+    console.log(`    ${colors7.green(pkg.padEnd(20))}	${version2}`);
   }
   if (versions.size > 1) {
-    console.warn(colors5.yellow("WARNING: Multiple versions of Zenstack packages detected. This may cause issues."));
+    console.warn(colors7.yellow("WARNING: Multiple versions of Zenstack packages detected. This may cause issues."));
   }
 }
 __name(run5, "run");
-async function getZenStackPackages(projectPath) {
-  let pkgJson;
-  const resolvedPath = path5.resolve(projectPath);
-  try {
-    pkgJson = (await import(path5.join(resolvedPath, "package.json"), {
-      with: {
-        type: "json"
-      }
-    })).default;
-  } catch {
-    return [];
-  }
-  const packages = Array.from(new Set([
-    ...Object.keys(pkgJson.dependencies ?? {}),
-    ...Object.keys(pkgJson.devDependencies ?? {})
-  ].filter((p) => p.startsWith("@zenstackhq/") || p === "zenstack"))).sort();
-  const result = await Promise.all(packages.map(async (pkg) => {
-    try {
-      const depPkgJson = (await import(`${pkg}/package.json`, {
-        with: {
-          type: "json"
-        }
-      })).default;
-      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");
 
 // src/actions/init.ts
-import colors6 from "colors";
+import colors8 from "colors";
 import fs7 from "fs";
 import path6 from "path";
-import ora2 from "ora";
+import ora3 from "ora";
 import { detect, resolveCommand } from "package-manager-detector";
 
 // src/actions/templates.ts
@@ -731,7 +3323,7 @@ async function run6(projectPath) {
       name: "npm"
     };
   }
-  console.log(colors6.gray(`Using package manager: ${pm.agent}`));
+  console.log(colors8.gray(`Using package manager: ${pm.agent}`));
   for (const pkg of packages) {
     const resolved = resolveCommand(pm.agent, "add", [
       pkg.name,
@@ -742,7 +3334,7 @@ async function run6(projectPath) {
     if (!resolved) {
       throw new CliError(`Unable to determine how to install package "${pkg.name}". Please install it manually.`);
     }
-    const spinner = ora2(`Installing "${pkg.name}"`).start();
+    const spinner = ora3(`Installing "${pkg.name}"`).start();
     try {
       execSync(`${resolved.command} ${resolved.args.join(" ")}`, {
         cwd: projectPath
@@ -760,11 +3352,11 @@ async function run6(projectPath) {
   if (!fs7.existsSync(path6.join(projectPath, generationFolder, "schema.zmodel"))) {
     fs7.writeFileSync(path6.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
   } else {
-    console.log(colors6.yellow("Schema file already exists. Skipping generation of sample."));
+    console.log(colors8.yellow("Schema file already exists. Skipping generation of sample."));
   }
-  console.log(colors6.green("ZenStack project initialized successfully!"));
-  console.log(colors6.gray(`See "${generationFolder}/schema.zmodel" for your database schema.`));
-  console.log(colors6.gray("Run `zenstack generate` to compile the the schema into a TypeScript file."));
+  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");
 
@@ -773,19 +3365,19 @@ import fs8 from "fs";
 import path7 from "path";
 
 // src/actions/seed.ts
-import colors7 from "colors";
+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(colors7.yellow("No seed script defined in package.json. Skipping seeding."));
+      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(colors7.gray(`Running seed script "${command}"...`));
+    console.log(colors9.gray(`Running seed script "${command}"...`));
   }
   try {
     await execaCommand(command, {
@@ -793,7 +3385,7 @@ async function run7(options, args) {
       stderr: "inherit"
     });
   } catch (err) {
-    console.error(colors7.red(err instanceof Error ? err.message : String(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.");
   }
 }
@@ -914,8 +3506,8 @@ function handleSubProcessError2(err) {
 __name(handleSubProcessError2, "handleSubProcessError");
 
 // src/actions/proxy.ts
-import { isDataSource as isDataSource2, isInvocationExpr, isLiteralExpr } from "@zenstackhq/language/ast";
-import { getStringLiteral } from "@zenstackhq/language/utils";
+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";
@@ -923,7 +3515,7 @@ import { SqliteDialect } from "@zenstackhq/orm/dialects/sqlite";
 import { RPCApiHandler } from "@zenstackhq/server/api";
 import { ZenStackMiddleware } from "@zenstackhq/server/express";
 import SQLite from "better-sqlite3";
-import colors9 from "colors";
+import colors11 from "colors";
 import cors from "cors";
 import express from "express";
 import { createJiti as createJiti2 } from "jiti";
@@ -932,11 +3524,11 @@ import path9 from "path";
 import { Pool as PgPool } from "pg";
 
 // src/utils/version-utils.ts
-import colors8 from "colors";
+import colors10 from "colors";
 import fs9 from "fs";
 import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
-import semver from "semver";
+import semver2 from "semver";
 var CHECK_VERSION_TIMEOUT = 2e3;
 var VERSION_CHECK_TAG = "next";
 function getVersion() {
@@ -956,8 +3548,8 @@ async function checkNewVersion() {
   } catch {
     return;
   }
-  if (latestVersion && currVersion && semver.gt(latestVersion, currVersion)) {
-    console.log(`A newer version ${colors8.cyan(latestVersion)} is available.`);
+  if (latestVersion && currVersion && semver2.gt(latestVersion, currVersion)) {
+    console.log(`A newer version ${colors10.cyan(latestVersion)} is available.`);
   }
 }
 __name(checkNewVersion, "checkNewVersion");
@@ -971,7 +3563,7 @@ async function getLatestVersion() {
   if (fetchResult.ok) {
     const data = await fetchResult.json();
     const latestVersion = data?.version;
-    if (typeof latestVersion === "string" && semver.valid(latestVersion)) {
+    if (typeof latestVersion === "string" && semver2.valid(latestVersion)) {
       return latestVersion;
     }
   }
@@ -987,7 +3579,7 @@ async function run9(options) {
   ];
   const log = options.logLevel?.filter((level) => allowedLogLevels.includes(level));
   const schemaFile = getSchemaFile(options.schema);
-  console.log(colors9.gray(`Loading ZModel schema from: ${schemaFile}`));
+  console.log(colors11.gray(`Loading ZModel schema from: ${schemaFile}`));
   let outputPath = getOutputPath(options, schemaFile);
   if (!path9.isAbsolute(outputPath)) {
     outputPath = path9.resolve(process.cwd(), outputPath);
@@ -1002,7 +3594,7 @@ async function run9(options) {
     }
     databaseUrl = evaluateUrl(schemaUrl);
   }
-  const provider = getStringLiteral(dataSource?.fields.find((f) => f.name === "provider")?.value);
+  const provider = getStringLiteral2(dataSource?.fields.find((f) => f.name === "provider")?.value);
   const dialect = createDialect(provider, databaseUrl, outputPath);
   const jiti = createJiti2(import.meta.url);
   const schemaModule = await jiti.import(path9.join(outputPath, "schema"));
@@ -1034,10 +3626,10 @@ async function run9(options) {
 __name(run9, "run");
 function evaluateUrl(schemaUrl) {
   if (isLiteralExpr(schemaUrl)) {
-    return getStringLiteral(schemaUrl);
-  } else if (isInvocationExpr(schemaUrl)) {
+    return getStringLiteral2(schemaUrl);
+  } else if (isInvocationExpr2(schemaUrl)) {
     const envFunction = schemaUrl;
-    const envName = getStringLiteral(envFunction.args[0]?.value);
+    const envName = getStringLiteral2(envFunction.args[0]?.value);
     const envValue = process.env[envName];
     if (!envValue) {
       throw new CliError(`Environment variable ${envName} is not set`);
@@ -1073,20 +3665,20 @@ function createDialect(provider, databaseUrl, outputPath) {
           resolvedUrl = path9.join(outputPath, filePath);
         }
       }
-      console.log(colors9.gray(`Connecting to SQLite database at: ${resolvedUrl}`));
+      console.log(colors11.gray(`Connecting to SQLite database at: ${resolvedUrl}`));
       return new SqliteDialect({
         database: new SQLite(resolvedUrl)
       });
     }
     case "postgresql":
-      console.log(colors9.gray(`Connecting to PostgreSQL database at: ${redactDatabaseUrl(databaseUrl)}`));
+      console.log(colors11.gray(`Connecting to PostgreSQL database at: ${redactDatabaseUrl(databaseUrl)}`));
       return new PostgresDialect({
         pool: new PgPool({
           connectionString: databaseUrl
         })
       });
     case "mysql":
-      console.log(colors9.gray(`Connecting to MySQL database at: ${redactDatabaseUrl(databaseUrl)}`));
+      console.log(colors11.gray(`Connecting to MySQL database at: ${redactDatabaseUrl(databaseUrl)}`));
       return new MysqlDialect({
         pool: createMysqlPool(databaseUrl)
       });
@@ -1119,11 +3711,11 @@ function startServer(client, schema, options) {
   });
   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: ${colors9.blue("https://studio.zenstack.dev")}`);
+    console.log(`You can visit ZenStack Studio at: ${colors11.blue("https://studio.zenstack.dev")}`);
   });
   server.on("error", (err) => {
     if (err.code === "EADDRINUSE") {
-      console.error(colors9.red(`Port ${options.port} is already in use. Please choose a different port using -p option.`));
+      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}`);
     }
@@ -1153,7 +3745,7 @@ import fs13 from "fs";
 import * as os2 from "os";
 
 // src/constants.ts
-var TELEMETRY_TRACKING_TOKEN = "74944eb779d7d3b4ce185be843fde9fc";
+var TELEMETRY_TRACKING_TOKEN = "<TELEMETRY_TRACKING_TOKEN>";
 
 // src/utils/is-ci.ts
 import { env } from "process";
@@ -1416,7 +4008,7 @@ var proxyAction = /* @__PURE__ */ __name(async (options) => {
 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(`${colors10.bold.blue("\u03B6")} ZenStack is the modern data layer for TypeScript apps.
+  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.`);
@@ -1431,6 +4023,7 @@ Documentation: https://zenstack.dev/docs`).showHelpAfterError().showSuggestionAf
   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.:
@@ -1467,10 +4060,10 @@ async function main() {
     if (e instanceof CommanderError) {
       exitCode = e.exitCode;
     } else if (e instanceof CliError) {
-      console.error(colors10.red(e.message));
+      console.error(colors12.red(e.message));
       exitCode = 1;
     } else {
-      console.error(colors10.red(`Unhandled error: ${e}`));
+      console.error(colors12.red(`Unhandled error: ${e}`));
       exitCode = 1;
     }
   }