@zenstackhq/cli 3.3.0-beta.2 → 3.3.0-beta.4

package/dist/index.cjs

@@ -28,8 +28,8 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 
 // src/index.ts
-var import_language4 = require("@zenstackhq/language");
-var import_colors9 = __toESM(require("colors"), 1);
+var import_language5 = require("@zenstackhq/language");
+var import_colors10 = __toESM(require("colors"), 1);
 var import_commander = require("commander");
 
 // src/actions/check.ts
@@ -170,6 +170,18 @@ async function requireDataSourceUrl(schemaFile) {
   }
 }
 __name(requireDataSourceUrl, "requireDataSourceUrl");
+function getOutputPath(options, schemaFile) {
+  if (options.output) {
+    return options.output;
+  }
+  const pkgJsonConfig = getPkgJsonConfig(process.cwd());
+  if (pkgJsonConfig.output) {
+    return pkgJsonConfig.output;
+  } else {
+    return import_node_path.default.dirname(schemaFile);
+  }
+}
+__name(getOutputPath, "getOutputPath");
 
 // src/actions/check.ts
 async function run(options) {
@@ -231,7 +243,7 @@ function execPrisma(args, options) {
     execPackage(`prisma ${args}`, _options);
     return;
   }
-  execSync(`node ${prismaPath} ${args}`, _options);
+  execSync(`node "${prismaPath}" ${args}`, _options);
 }
 __name(execPrisma, "execPrisma");
 
@@ -466,18 +478,6 @@ Check documentation: https://zenstack.dev/docs/`);
   return model;
 }
 __name(pureGenerate, "pureGenerate");
-function getOutputPath(options, schemaFile) {
-  if (options.output) {
-    return options.output;
-  }
-  const pkgJsonConfig = getPkgJsonConfig(process.cwd());
-  if (pkgJsonConfig.output) {
-    return pkgJsonConfig.output;
-  } else {
-    return import_node_path4.default.dirname(schemaFile);
-  }
-}
-__name(getOutputPath, "getOutputPath");
 async function runPlugins(schemaFile, model, outputPath, options) {
   const plugins = model.declarations.filter(import_ast2.isPlugin);
   const processedPlugins = [];
@@ -929,6 +929,211 @@ function handleSubProcessError2(err) {
 }
 __name(handleSubProcessError2, "handleSubProcessError");
 
+// src/actions/proxy.ts
+var import_language4 = require("@zenstackhq/language");
+var import_ast3 = require("@zenstackhq/language/ast");
+var import_utils2 = require("@zenstackhq/language/utils");
+var import_orm = require("@zenstackhq/orm");
+var import_mysql = require("@zenstackhq/orm/dialects/mysql");
+var import_postgres = require("@zenstackhq/orm/dialects/postgres");
+var import_sqlite = require("@zenstackhq/orm/dialects/sqlite");
+var import_api = require("@zenstackhq/server/api");
+var import_express = require("@zenstackhq/server/express");
+var import_better_sqlite3 = __toESM(require("better-sqlite3"), 1);
+var import_colors9 = __toESM(require("colors"), 1);
+var import_cors = __toESM(require("cors"), 1);
+var import_express2 = __toESM(require("express"), 1);
+var import_jiti2 = require("jiti");
+var import_mysql2 = require("mysql2");
+var import_node_path9 = __toESM(require("path"), 1);
+var import_pg = require("pg");
+
+// src/utils/version-utils.ts
+var import_colors8 = __toESM(require("colors"), 1);
+var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_path8 = __toESM(require("path"), 1);
+var import_node_url2 = require("url");
+var import_semver = __toESM(require("semver"), 1);
+var import_meta2 = {};
+var CHECK_VERSION_TIMEOUT = 2e3;
+var VERSION_CHECK_TAG = "next";
+function getVersion() {
+  try {
+    const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path8.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
+    return JSON.parse(import_node_fs9.default.readFileSync(import_node_path8.default.join(_dirname, "../package.json"), "utf8")).version;
+  } catch {
+    return void 0;
+  }
+}
+__name(getVersion, "getVersion");
+async function checkNewVersion() {
+  const currVersion = getVersion();
+  let latestVersion;
+  try {
+    latestVersion = await getLatestVersion();
+  } catch {
+    return;
+  }
+  if (latestVersion && currVersion && import_semver.default.gt(latestVersion, currVersion)) {
+    console.log(`A newer version ${import_colors8.default.cyan(latestVersion)} is available.`);
+  }
+}
+__name(checkNewVersion, "checkNewVersion");
+async function getLatestVersion() {
+  const fetchResult = await fetch(`https://registry.npmjs.org/@zenstackhq/cli/${VERSION_CHECK_TAG}`, {
+    headers: {
+      accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
+    },
+    signal: AbortSignal.timeout(CHECK_VERSION_TIMEOUT)
+  });
+  if (fetchResult.ok) {
+    const data = await fetchResult.json();
+    const latestVersion = data?.version;
+    if (typeof latestVersion === "string" && import_semver.default.valid(latestVersion)) {
+      return latestVersion;
+    }
+  }
+  throw new Error("invalid npm registry response");
+}
+__name(getLatestVersion, "getLatestVersion");
+
+// src/actions/proxy.ts
+var import_meta3 = {};
+async function run9(options) {
+  const schemaFile = getSchemaFile(options.schema);
+  console.log(import_colors9.default.gray(`Loading ZModel schema from: ${schemaFile}`));
+  let outputPath = getOutputPath(options, schemaFile);
+  if (!import_node_path9.default.isAbsolute(outputPath)) {
+    outputPath = import_node_path9.default.resolve(process.cwd(), outputPath);
+  }
+  const model = await loadSchemaDocument(schemaFile);
+  const dataSource = model.declarations.find(import_ast3.isDataSource);
+  let databaseUrl = options.databaseUrl;
+  if (!databaseUrl) {
+    const schemaUrl = dataSource?.fields.find((f) => f.name === "url")?.value;
+    if (!schemaUrl) {
+      throw new CliError(`The schema's "datasource" does not have a "url" field, please provide it with -d option.`);
+    }
+    const zModelGenerator = new import_language4.ZModelCodeGenerator();
+    const url = zModelGenerator.generate(schemaUrl);
+    databaseUrl = evaluateUrl(url);
+  }
+  const provider = (0, import_utils2.getStringLiteral)(dataSource?.fields.find((f) => f.name === "provider")?.value);
+  const dialect = createDialect(provider, databaseUrl, outputPath);
+  const jiti = (0, import_jiti2.createJiti)(import_meta3.url);
+  const schemaModule = await jiti.import(import_node_path9.default.join(outputPath, "schema"));
+  const allowedLogLevels = [
+    "error",
+    "query"
+  ];
+  const log = options.logLevel?.filter((level) => allowedLogLevels.includes(level));
+  const db = new import_orm.ZenStackClient(schemaModule.schema, {
+    dialect,
+    log: log && log.length > 0 ? log : void 0
+  });
+  try {
+    await db.$connect();
+  } catch (err) {
+    throw new CliError(`Failed to connect to the database: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  startServer(db, schemaModule.schema, options);
+}
+__name(run9, "run");
+function evaluateUrl(value) {
+  const env2 = /* @__PURE__ */ __name((varName) => {
+    const envValue = process.env[varName];
+    if (!envValue) {
+      throw new CliError(`Environment variable ${varName} is not set`);
+    }
+    return envValue;
+  }, "env");
+  try {
+    const urlFn = new Function("env", `return ${value}`);
+    const url = urlFn(env2);
+    return url;
+  } catch (err) {
+    if (err instanceof CliError) {
+      throw err;
+    }
+    throw new CliError("Could not evaluate datasource url from schema, you could provide it via -d option.");
+  }
+}
+__name(evaluateUrl, "evaluateUrl");
+function createDialect(provider, databaseUrl, outputPath) {
+  switch (provider) {
+    case "sqlite": {
+      let resolvedUrl = databaseUrl.trim();
+      if (resolvedUrl.startsWith("file:")) {
+        const filePath = resolvedUrl.substring("file:".length);
+        if (!import_node_path9.default.isAbsolute(filePath)) {
+          resolvedUrl = import_node_path9.default.join(outputPath, filePath);
+        }
+      }
+      console.log(import_colors9.default.gray(`Connecting to SQLite database at: ${resolvedUrl}`));
+      return new import_sqlite.SqliteDialect({
+        database: new import_better_sqlite3.default(resolvedUrl)
+      });
+    }
+    case "postgresql":
+      console.log(import_colors9.default.gray(`Connecting to PostgreSQL database at: ${databaseUrl}`));
+      return new import_postgres.PostgresDialect({
+        pool: new import_pg.Pool({
+          connectionString: databaseUrl
+        })
+      });
+    case "mysql":
+      console.log(import_colors9.default.gray(`Connecting to MySQL database at: ${databaseUrl}`));
+      return new import_mysql.MysqlDialect({
+        pool: (0, import_mysql2.createPool)(databaseUrl)
+      });
+    default:
+      throw new CliError(`Unsupported database provider: ${provider}`);
+  }
+}
+__name(createDialect, "createDialect");
+function startServer(client, schema, options) {
+  const app = (0, import_express2.default)();
+  app.use((0, import_cors.default)());
+  app.use(import_express2.default.json({
+    limit: "5mb"
+  }));
+  app.use(import_express2.default.urlencoded({
+    extended: true,
+    limit: "5mb"
+  }));
+  app.use("/api/model", (0, import_express.ZenStackMiddleware)({
+    apiHandler: new import_api.RPCApiHandler({
+      schema
+    }),
+    getClient: /* @__PURE__ */ __name(() => client, "getClient")
+  }));
+  app.get("/api/schema", (_req, res) => {
+    res.json({
+      ...schema,
+      zenstackVersion: getVersion()
+    });
+  });
+  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: ${import_colors9.default.blue("https://studio.zenstack.dev")}`);
+  });
+  process.on("SIGTERM", async () => {
+    server.close(() => {
+      console.log("\nZenStack proxy server closed");
+    });
+    await client.$disconnect();
+    process.exit(0);
+  });
+  process.on("SIGINT", async () => {
+    server.close(() => {
+      console.log("\nZenStack proxy server closed");
+    });
+    await client.$disconnect();
+    process.exit(0);
+  });
+}
+__name(startServer, "startServer");
+
 // src/telemetry.ts
 var import_mixpanel = require("mixpanel");
 var import_node_crypto2 = require("crypto");
@@ -943,14 +1148,14 @@ var import_node_process = require("process");
 var isInCi = import_node_process.env["CI"] !== "0" && import_node_process.env["CI"] !== "false" && ("CI" in import_node_process.env || "CONTINUOUS_INTEGRATION" in import_node_process.env || Object.keys(import_node_process.env).some((key) => key.startsWith("CI_")));
 
 // src/utils/is-container.ts
-var import_node_fs10 = __toESM(require("fs"), 1);
+var import_node_fs11 = __toESM(require("fs"), 1);
 
 // src/utils/is-docker.ts
-var import_node_fs9 = __toESM(require("fs"), 1);
+var import_node_fs10 = __toESM(require("fs"), 1);
 var isDockerCached;
 function hasDockerEnv() {
   try {
-    import_node_fs9.default.statSync("/.dockerenv");
+    import_node_fs10.default.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -959,7 +1164,7 @@ function hasDockerEnv() {
 __name(hasDockerEnv, "hasDockerEnv");
 function hasDockerCGroup() {
   try {
-    return import_node_fs9.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return import_node_fs10.default.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -977,7 +1182,7 @@ __name(isDocker, "isDocker");
 var cachedResult;
 var hasContainerEnv = /* @__PURE__ */ __name(() => {
   try {
-    import_node_fs10.default.statSync("/run/.containerenv");
+    import_node_fs11.default.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -994,7 +1199,7 @@ __name(isInContainer, "isInContainer");
 // src/utils/is-wsl.ts
 var import_node_process2 = __toESM(require("process"), 1);
 var import_node_os = __toESM(require("os"), 1);
-var import_node_fs11 = __toESM(require("fs"), 1);
+var import_node_fs12 = __toESM(require("fs"), 1);
 var isWsl = /* @__PURE__ */ __name(() => {
   if (import_node_process2.default.platform !== "linux") {
     return false;
@@ -1003,7 +1208,7 @@ var isWsl = /* @__PURE__ */ __name(() => {
     return true;
   }
   try {
-    return import_node_fs11.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+    return import_node_fs12.default.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
   } catch {
     return false;
   }
@@ -1066,57 +1271,8 @@ function getMachineId() {
 }
 __name(getMachineId, "getMachineId");
 
-// src/utils/version-utils.ts
-var import_colors8 = __toESM(require("colors"), 1);
-var import_node_fs12 = __toESM(require("fs"), 1);
-var import_node_path8 = __toESM(require("path"), 1);
-var import_node_url2 = require("url");
-var import_semver = __toESM(require("semver"), 1);
-var import_meta2 = {};
-var CHECK_VERSION_TIMEOUT = 2e3;
-var VERSION_CHECK_TAG = "next";
-function getVersion() {
-  try {
-    const _dirname = typeof __dirname !== "undefined" ? __dirname : import_node_path8.default.dirname((0, import_node_url2.fileURLToPath)(import_meta2.url));
-    return JSON.parse(import_node_fs12.default.readFileSync(import_node_path8.default.join(_dirname, "../package.json"), "utf8")).version;
-  } catch {
-    return void 0;
-  }
-}
-__name(getVersion, "getVersion");
-async function checkNewVersion() {
-  const currVersion = getVersion();
-  let latestVersion;
-  try {
-    latestVersion = await getLatestVersion();
-  } catch {
-    return;
-  }
-  if (latestVersion && currVersion && import_semver.default.gt(latestVersion, currVersion)) {
-    console.log(`A newer version ${import_colors8.default.cyan(latestVersion)} is available.`);
-  }
-}
-__name(checkNewVersion, "checkNewVersion");
-async function getLatestVersion() {
-  const fetchResult = await fetch(`https://registry.npmjs.org/@zenstackhq/cli/${VERSION_CHECK_TAG}`, {
-    headers: {
-      accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*"
-    },
-    signal: AbortSignal.timeout(CHECK_VERSION_TIMEOUT)
-  });
-  if (fetchResult.ok) {
-    const data = await fetchResult.json();
-    const latestVersion = data?.version;
-    if (typeof latestVersion === "string" && import_semver.default.valid(latestVersion)) {
-      return latestVersion;
-    }
-  }
-  throw new Error("invalid npm registry response");
-}
-__name(getLatestVersion, "getLatestVersion");
-
 // src/telemetry.ts
-var import_meta3 = {};
+var import_meta4 = {};
 var Telemetry = class {
   static {
     __name(this, "Telemetry");
@@ -1207,7 +1363,7 @@ var Telemetry = class {
   }
   getPrismaVersion() {
     try {
-      const packageJsonPath = import_meta3.resolve("prisma/package.json");
+      const packageJsonPath = import_meta4.resolve("prisma/package.json");
       const packageJsonUrl = new URL(packageJsonPath);
       const packageJson = JSON.parse(import_node_fs13.default.readFileSync(packageJsonUrl, "utf8"));
       return packageJson.version;
@@ -1243,10 +1399,13 @@ var formatAction = /* @__PURE__ */ __name(async (options) => {
 var seedAction = /* @__PURE__ */ __name(async (options, args) => {
   await telemetry.trackCommand("db seed", () => run7(options, args));
 }, "seedAction");
+var proxyAction = /* @__PURE__ */ __name(async (options) => {
+  await telemetry.trackCommand("proxy", () => run9(options));
+}, "proxyAction");
 function createProgram() {
   const program = new import_commander.Command("zen").alias("zenstack").helpOption("-h, --help", "Show this help message").version(getVersion(), "-v --version", "Show CLI version");
-  const schemaExtensions = import_language4.ZModelLanguageMetaData.fileExtensions.join(", ");
-  program.description(`${import_colors9.default.bold.blue("\u03B6")} ZenStack is the modern data layer for TypeScript apps.
+  const schemaExtensions = import_language5.ZModelLanguageMetaData.fileExtensions.join(", ");
+  program.description(`${import_colors10.default.bold.blue("\u03B6")} ZenStack is the modern data layer for TypeScript apps.
 
 Documentation: https://zenstack.dev/docs`).showHelpAfterError().showSuggestionAfterError();
   const schemaOption = new import_commander.Option("--schema <file>", `schema file (with extension ${schemaExtensions}). Defaults to "zenstack/schema.zmodel" unless specified in package.json.`);
@@ -1275,6 +1434,7 @@ Arguments following -- are passed to the seed script. E.g.: "zen db seed -- --us
   program.command("init").description("Initialize an existing project for ZenStack").argument("[path]", "project path", ".").addOption(noVersionCheckOption).action(initAction);
   program.command("check").description("Check a ZModel schema for syntax or semantic errors").addOption(schemaOption).addOption(noVersionCheckOption).action(checkAction);
   program.command("format").description("Format a ZModel schema file").addOption(schemaOption).addOption(noVersionCheckOption).action(formatAction);
+  program.command("proxy").alias("studio").description("Start the ZenStack proxy server").addOption(schemaOption).addOption(new import_commander.Option("-p, --port <port>", "port to run the proxy server on").default(8008)).addOption(new import_commander.Option("-o, --output <path>", "output directory for `zen generate` command")).addOption(new import_commander.Option("-d, --databaseUrl <url>", "database connection URL")).addOption(new import_commander.Option("-l, --logLevel <level>", "Query log levels (e.g., query, error)")).addOption(noVersionCheckOption).action(proxyAction);
   program.addHelpCommand("help [command]", "Display help for a command");
   program.hook("preAction", async (_thisCommand, actionCommand) => {
     if (actionCommand.getOptionValue("versionCheck") !== false) {
@@ -1296,14 +1456,17 @@ async function main() {
     if (e instanceof import_commander.CommanderError) {
       exitCode = e.exitCode;
     } else if (e instanceof CliError) {
-      console.error(import_colors9.default.red(e.message));
+      console.error(import_colors10.default.red(e.message));
       exitCode = 1;
     } else {
-      console.error(import_colors9.default.red(`Unhandled error: ${e}`));
+      console.error(import_colors10.default.red(`Unhandled error: ${e}`));
       exitCode = 1;
     }
   }
-  if (program.args.includes("generate") && (program.args.includes("-w") || program.args.includes("--watch"))) {
+  if (program.args.includes("generate") && (program.args.includes("-w") || program.args.includes("--watch")) || [
+    "proxy",
+    "studio"
+  ].some((cmd) => program.args.includes(cmd))) {
     return;
   }
   if (telemetry.isTracking) {