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

package/dist/index.js

@@ -13,7 +13,7 @@ var __export = (target, all) => {
 
 // src/index.ts
 import { ZModelLanguageMetaData as ZModelLanguageMetaData2 } from "@zenstackhq/language";
-import colors9 from "colors";
+import colors10 from "colors";
 import { Command, CommanderError, Option } from "commander";
 
 // src/actions/check.ts
@@ -154,6 +154,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 path.dirname(schemaFile);
+  }
+}
+__name(getOutputPath, "getOutputPath");
 
 // src/actions/check.ts
 async function run(options) {
@@ -214,7 +226,7 @@ function execPrisma(args, options) {
     execPackage(`prisma ${args}`, _options);
     return;
   }
-  execSync(`node ${prismaPath} ${args}`, _options);
+  execSync(`node "${prismaPath}" ${args}`, _options);
 }
 __name(execPrisma, "execPrisma");
 
@@ -449,18 +461,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 path4.dirname(schemaFile);
-  }
-}
-__name(getOutputPath, "getOutputPath");
 async function runPlugins(schemaFile, model, outputPath, options) {
   const plugins = model.declarations.filter(isPlugin);
   const processedPlugins = [];
@@ -912,6 +912,209 @@ function handleSubProcessError2(err) {
 }
 __name(handleSubProcessError2, "handleSubProcessError");
 
+// src/actions/proxy.ts
+import { ZModelCodeGenerator } from "@zenstackhq/language";
+import { isDataSource as isDataSource2 } from "@zenstackhq/language/ast";
+import { getStringLiteral } from "@zenstackhq/language/utils";
+import { ZenStackClient } from "@zenstackhq/orm";
+import { MysqlDialect } from "@zenstackhq/orm/dialects/mysql";
+import { PostgresDialect } from "@zenstackhq/orm/dialects/postgres";
+import { SqliteDialect } from "@zenstackhq/orm/dialects/sqlite";
+import { RPCApiHandler } from "@zenstackhq/server/api";
+import { ZenStackMiddleware } from "@zenstackhq/server/express";
+import SQLite from "better-sqlite3";
+import colors9 from "colors";
+import cors from "cors";
+import express from "express";
+import { createJiti as createJiti2 } from "jiti";
+import { createPool as createMysqlPool } from "mysql2";
+import path9 from "path";
+import { Pool as PgPool } from "pg";
+
+// src/utils/version-utils.ts
+import colors8 from "colors";
+import fs9 from "fs";
+import path8 from "path";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import semver from "semver";
+var CHECK_VERSION_TIMEOUT = 2e3;
+var VERSION_CHECK_TAG = "next";
+function getVersion() {
+  try {
+    const _dirname = typeof __dirname !== "undefined" ? __dirname : path8.dirname(fileURLToPath2(import.meta.url));
+    return JSON.parse(fs9.readFileSync(path8.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 && semver.gt(latestVersion, currVersion)) {
+    console.log(`A newer version ${colors8.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" && semver.valid(latestVersion)) {
+      return latestVersion;
+    }
+  }
+  throw new Error("invalid npm registry response");
+}
+__name(getLatestVersion, "getLatestVersion");
+
+// src/actions/proxy.ts
+async function run9(options) {
+  const schemaFile = getSchemaFile(options.schema);
+  console.log(colors9.gray(`Loading ZModel schema from: ${schemaFile}`));
+  let outputPath = getOutputPath(options, schemaFile);
+  if (!path9.isAbsolute(outputPath)) {
+    outputPath = path9.resolve(process.cwd(), outputPath);
+  }
+  const model = await loadSchemaDocument(schemaFile);
+  const dataSource = model.declarations.find(isDataSource2);
+  let databaseUrl = options.databaseUrl;
+  if (!databaseUrl) {
+    const schemaUrl = dataSource?.fields.find((f) => f.name === "url")?.value;
+    if (!schemaUrl) {
+      throw new CliError(`The schema's "datasource" does not have a "url" field, please provide it with -d option.`);
+    }
+    const zModelGenerator = new ZModelCodeGenerator();
+    const url = zModelGenerator.generate(schemaUrl);
+    databaseUrl = evaluateUrl(url);
+  }
+  const provider = getStringLiteral(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"));
+  const allowedLogLevels = [
+    "error",
+    "query"
+  ];
+  const log = options.logLevel?.filter((level) => allowedLogLevels.includes(level));
+  const db = new 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 (!path9.isAbsolute(filePath)) {
+          resolvedUrl = path9.join(outputPath, filePath);
+        }
+      }
+      console.log(colors9.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: ${databaseUrl}`));
+      return new PostgresDialect({
+        pool: new PgPool({
+          connectionString: databaseUrl
+        })
+      });
+    case "mysql":
+      console.log(colors9.gray(`Connecting to MySQL database at: ${databaseUrl}`));
+      return new MysqlDialect({
+        pool: createMysqlPool(databaseUrl)
+      });
+    default:
+      throw new CliError(`Unsupported database provider: ${provider}`);
+  }
+}
+__name(createDialect, "createDialect");
+function startServer(client, schema, options) {
+  const app = express();
+  app.use(cors());
+  app.use(express.json({
+    limit: "5mb"
+  }));
+  app.use(express.urlencoded({
+    extended: true,
+    limit: "5mb"
+  }));
+  app.use("/api/model", ZenStackMiddleware({
+    apiHandler: new RPCApiHandler({
+      schema
+    }),
+    getClient: /* @__PURE__ */ __name(() => client, "getClient")
+  }));
+  app.get("/api/schema", (_req, res) => {
+    res.json({
+      ...schema,
+      zenstackVersion: getVersion()
+    });
+  });
+  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")}`);
+  });
+  process.on("SIGTERM", async () => {
+    server.close(() => {
+      console.log("\nZenStack proxy server closed");
+    });
+    await client.$disconnect();
+    process.exit(0);
+  });
+  process.on("SIGINT", async () => {
+    server.close(() => {
+      console.log("\nZenStack proxy server closed");
+    });
+    await client.$disconnect();
+    process.exit(0);
+  });
+}
+__name(startServer, "startServer");
+
 // src/telemetry.ts
 import { init } from "mixpanel";
 import { randomUUID as randomUUID2 } from "crypto";
@@ -926,14 +1129,14 @@ import { env } from "process";
 var isInCi = env["CI"] !== "0" && env["CI"] !== "false" && ("CI" in env || "CONTINUOUS_INTEGRATION" in env || Object.keys(env).some((key) => key.startsWith("CI_")));
 
 // src/utils/is-container.ts
-import fs10 from "fs";
+import fs11 from "fs";
 
 // src/utils/is-docker.ts
-import fs9 from "fs";
+import fs10 from "fs";
 var isDockerCached;
 function hasDockerEnv() {
   try {
-    fs9.statSync("/.dockerenv");
+    fs10.statSync("/.dockerenv");
     return true;
   } catch {
     return false;
@@ -942,7 +1145,7 @@ function hasDockerEnv() {
 __name(hasDockerEnv, "hasDockerEnv");
 function hasDockerCGroup() {
   try {
-    return fs9.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+    return fs10.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
   } catch {
     return false;
   }
@@ -960,7 +1163,7 @@ __name(isDocker, "isDocker");
 var cachedResult;
 var hasContainerEnv = /* @__PURE__ */ __name(() => {
   try {
-    fs10.statSync("/run/.containerenv");
+    fs11.statSync("/run/.containerenv");
     return true;
   } catch {
     return false;
@@ -977,7 +1180,7 @@ __name(isInContainer, "isInContainer");
 // src/utils/is-wsl.ts
 import process2 from "process";
 import os from "os";
-import fs11 from "fs";
+import fs12 from "fs";
 var isWsl = /* @__PURE__ */ __name(() => {
   if (process2.platform !== "linux") {
     return false;
@@ -986,7 +1189,7 @@ var isWsl = /* @__PURE__ */ __name(() => {
     return true;
   }
   try {
-    return fs11.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
+    return fs12.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft");
   } catch {
     return false;
   }
@@ -1049,54 +1252,6 @@ function getMachineId() {
 }
 __name(getMachineId, "getMachineId");
 
-// src/utils/version-utils.ts
-import colors8 from "colors";
-import fs12 from "fs";
-import path8 from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-import semver from "semver";
-var CHECK_VERSION_TIMEOUT = 2e3;
-var VERSION_CHECK_TAG = "next";
-function getVersion() {
-  try {
-    const _dirname = typeof __dirname !== "undefined" ? __dirname : path8.dirname(fileURLToPath2(import.meta.url));
-    return JSON.parse(fs12.readFileSync(path8.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 && semver.gt(latestVersion, currVersion)) {
-    console.log(`A newer version ${colors8.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" && semver.valid(latestVersion)) {
-      return latestVersion;
-    }
-  }
-  throw new Error("invalid npm registry response");
-}
-__name(getLatestVersion, "getLatestVersion");
-
 // src/telemetry.ts
 var Telemetry = class {
   static {
@@ -1224,10 +1379,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 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(`${colors9.bold.blue("\u03B6")} ZenStack is the modern data layer for TypeScript apps.
+  program.description(`${colors10.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.`);
@@ -1256,6 +1414,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 Option("-p, --port <port>", "port to run the proxy server on").default(8008)).addOption(new Option("-o, --output <path>", "output directory for `zen generate` command")).addOption(new Option("-d, --databaseUrl <url>", "database connection URL")).addOption(new Option("-l, --logLevel <level>", "Query log levels (e.g., query, error)")).addOption(noVersionCheckOption).action(proxyAction);
   program.addHelpCommand("help [command]", "Display help for a command");
   program.hook("preAction", async (_thisCommand, actionCommand) => {
     if (actionCommand.getOptionValue("versionCheck") !== false) {
@@ -1277,14 +1436,17 @@ async function main() {
     if (e instanceof CommanderError) {
       exitCode = e.exitCode;
     } else if (e instanceof CliError) {
-      console.error(colors9.red(e.message));
+      console.error(colors10.red(e.message));
       exitCode = 1;
     } else {
-      console.error(colors9.red(`Unhandled error: ${e}`));
+      console.error(colors10.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) {