@zenstackhq/cli 3.4.0-beta.3 → 3.4.0

package/dist/index.js

@@ -37,6 +37,8 @@ var CliError = class extends Error {
 };
 
 // src/actions/action-utils.ts
+import terminalLink from "terminal-link";
+import { z } from "zod";
 function getSchemaFile(file) {
   if (file) {
     if (!fs.existsSync(file)) {
@@ -212,6 +214,58 @@ async function getZenStackPackages(searchPath) {
   return result.filter((p) => !!p);
 }
 __name(getZenStackPackages, "getZenStackPackages");
+var FETCH_CLI_MAX_TIME = 1e3;
+var CLI_CONFIG_ENDPOINT = "https://zenstack.dev/config/cli-v3.json";
+var usageTipsSchema = z.object({
+  notifications: z.array(z.object({
+    title: z.string(),
+    url: z.url().optional(),
+    active: z.boolean()
+  }))
+});
+function startUsageTipsFetch() {
+  let fetchedData = void 0;
+  let fetchComplete = false;
+  const start = Date.now();
+  const controller = new AbortController();
+  fetch(CLI_CONFIG_ENDPOINT, {
+    headers: {
+      accept: "application/json"
+    },
+    signal: controller.signal
+  }).then(async (res) => {
+    if (!res.ok) return;
+    const data = await res.json();
+    const parseResult = usageTipsSchema.safeParse(data);
+    if (parseResult.success) {
+      fetchedData = parseResult.data;
+    }
+  }).catch(() => {
+  }).finally(() => {
+    fetchComplete = true;
+  });
+  return async () => {
+    const elapsed = Date.now() - start;
+    if (!fetchComplete && elapsed < FETCH_CLI_MAX_TIME) {
+      await new Promise((resolve) => setTimeout(resolve, FETCH_CLI_MAX_TIME - elapsed));
+    }
+    if (!fetchComplete) {
+      controller.abort();
+      return;
+    }
+    if (!fetchedData) return;
+    const activeItems = fetchedData.notifications.filter((item) => item.active);
+    if (activeItems.length > 0) {
+      const item = activeItems[Math.floor(Math.random() * activeItems.length)];
+      if (item.url) {
+        console.log(terminalLink(item.title, item.url));
+      } else {
+        console.log(item.title);
+      }
+    }
+  };
+}
+__name(startUsageTipsFetch, "startUsageTipsFetch");
 
 // src/actions/check.ts
 async function run(options) {
@@ -2183,8 +2237,8 @@ var sqlite = {
     return void 0;
   },
   async introspect(connectionString, _options) {
-    const SQLite2 = (await import("better-sqlite3")).default;
-    const db = new SQLite2(connectionString, {
+    const SQLite = (await import("better-sqlite3")).default;
+    const db = new SQLite(connectionString, {
       readonly: true
     });
     try {
@@ -2881,13 +2935,14 @@ import { invariant, singleDebounce } from "@zenstackhq/common-helpers";
 import { ZModelLanguageMetaData } from "@zenstackhq/language";
 import { isPlugin } from "@zenstackhq/language/ast";
 import { getLiteral, getLiteralArray as getLiteralArray2 } from "@zenstackhq/language/utils";
+import { watch } from "chokidar";
 import colors6 from "colors";
 import { createJiti } from "jiti";
 import fs6 from "fs";
 import path5 from "path";
 import { pathToFileURL } from "url";
-import { watch } from "chokidar";
 import ora2 from "ora";
+import semver from "semver";
 
 // src/plugins/index.ts
 var plugins_exports = {};
@@ -2942,25 +2997,30 @@ var plugin2 = {
     if (importWithFileExtension && typeof importWithFileExtension !== "string") {
       throw new Error('The "importWithFileExtension" option must be a string if specified.');
     }
+    const generateModelTypes = pluginOptions["generateModels"] !== false;
+    const generateInputTypes = pluginOptions["generateInput"] !== false;
     await new TsSchemaGenerator().generate(model, {
       outDir,
       lite,
       liteOnly,
-      importWithFileExtension
+      importWithFileExtension,
+      generateModelTypes,
+      generateInputTypes
     });
   }
 };
 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 maybeShowUsageTips = options.tips && !options.silent && !options.watch ? startUsageTipsFetch() : void 0;
   const model = await pureGenerate(options, false);
+  await maybeShowUsageTips?.();
   if (options.watch) {
     const logsEnabled = !options.silent;
     if (logsEnabled) {
@@ -3078,12 +3138,18 @@ async function runPlugins(schemaFile, model, outputPath, options) {
     if (cliPlugin) {
       const pluginOptions = getPluginOptions(plugin3);
       if (provider === "@core/typescript") {
-        if (pluginOptions["lite"] === void 0) {
+        if (options.lite !== void 0) {
           pluginOptions["lite"] = options.lite;
         }
-        if (pluginOptions["liteOnly"] === void 0) {
+        if (options.liteOnly !== void 0) {
           pluginOptions["liteOnly"] = options.liteOnly;
         }
+        if (options.generateModels !== void 0) {
+          pluginOptions["generateModels"] = options.generateModels;
+        }
+        if (options.generateInput !== void 0) {
+          pluginOptions["generateInput"] = options.generateInput;
+        }
       }
       processedPlugins.push({
         cliPlugin,
@@ -3096,7 +3162,9 @@ async function runPlugins(schemaFile, model, outputPath, options) {
       plugin: typescript_default,
       options: {
         lite: options.lite,
-        liteOnly: options.liteOnly
+        liteOnly: options.liteOnly,
+        generateModels: options.generateModels,
+        generateInput: options.generateInput
       }
     }
   ];
@@ -3514,14 +3582,11 @@ 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 colors11 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 colors10 from "colors";
@@ -3530,7 +3595,7 @@ import path8 from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import semver2 from "semver";
 var CHECK_VERSION_TIMEOUT = 2e3;
-var VERSION_CHECK_TAG = "next";
+var VERSION_CHECK_TAG = "latest";
 function getVersion() {
   try {
     const _dirname = typeof __dirname !== "undefined" ? __dirname : path8.dirname(fileURLToPath2(import.meta.url));
@@ -3595,7 +3660,7 @@ async function run9(options) {
     databaseUrl = evaluateUrl(schemaUrl);
   }
   const provider = getStringLiteral2(dataSource?.fields.find((f) => f.name === "provider")?.value);
-  const dialect = createDialect(provider, databaseUrl, outputPath);
+  const dialect = await createDialect(provider, databaseUrl, outputPath);
   const jiti = createJiti2(import.meta.url);
   const schemaModule = await jiti.import(path9.join(outputPath, "schema"));
   const schema = schemaModule.schema;
@@ -3655,9 +3720,15 @@ function redactDatabaseUrl(url) {
   }
 }
 __name(redactDatabaseUrl, "redactDatabaseUrl");
-function createDialect(provider, databaseUrl, outputPath) {
+async function createDialect(provider, databaseUrl, outputPath) {
   switch (provider) {
     case "sqlite": {
+      let SQLite;
+      try {
+        SQLite = (await import("better-sqlite3")).default;
+      } catch {
+        throw new CliError(`Package "better-sqlite3" is required for SQLite support. Please install it with: npm install better-sqlite3`);
+      }
       let resolvedUrl = databaseUrl.trim();
       if (resolvedUrl.startsWith("file:")) {
         const filePath = resolvedUrl.substring("file:".length);
@@ -3670,18 +3741,32 @@ function createDialect(provider, databaseUrl, outputPath) {
         database: new SQLite(resolvedUrl)
       });
     }
-    case "postgresql":
+    case "postgresql": {
+      let PgPool;
+      try {
+        PgPool = (await import("pg")).Pool;
+      } catch {
+        throw new CliError(`Package "pg" is required for PostgreSQL support. Please install it with: npm install pg`);
+      }
       console.log(colors11.gray(`Connecting to PostgreSQL database at: ${redactDatabaseUrl(databaseUrl)}`));
       return new PostgresDialect({
         pool: new PgPool({
           connectionString: databaseUrl
         })
       });
-    case "mysql":
+    }
+    case "mysql": {
+      let createMysqlPool;
+      try {
+        createMysqlPool = (await import("mysql2")).createPool;
+      } catch {
+        throw new CliError(`Package "mysql2" is required for MySQL support. Please install it with: npm install mysql2`);
+      }
       console.log(colors11.gray(`Connecting to MySQL database at: ${redactDatabaseUrl(databaseUrl)}`));
       return new MysqlDialect({
         pool: createMysqlPool(databaseUrl)
       });
+    }
     default:
       throw new CliError(`Unsupported database provider: ${provider}`);
   }
@@ -3745,7 +3830,7 @@ import fs13 from "fs";
 import * as os2 from "os";
 
 // src/constants.ts
-var TELEMETRY_TRACKING_TOKEN = "<TELEMETRY_TRACKING_TOKEN>";
+var TELEMETRY_TRACKING_TOKEN = "74944eb779d7d3b4ce185be843fde9fc";
 
 // src/utils/is-ci.ts
 import { env } from "process";
@@ -4005,6 +4090,17 @@ var seedAction = /* @__PURE__ */ __name(async (options, args) => {
 var proxyAction = /* @__PURE__ */ __name(async (options) => {
   await telemetry.trackCommand("proxy", () => run9(options));
 }, "proxyAction");
+function triStateBooleanOption(flag, description) {
+  return new Option(flag, description).choices([
+    "true",
+    "false"
+  ]).argParser((value) => {
+    if (value === void 0 || value === "true") return true;
+    if (value === "false") return false;
+    throw new CliError(`Invalid value for ${flag}: ${value}`);
+  });
+}
+__name(triStateBooleanOption, "triStateBooleanOption");
 function createProgram() {
   const program = new Command("zen").alias("zenstack").helpOption("-h, --help", "Show this help message").version(getVersion(), "-v --version", "Show CLI version");
   const schemaExtensions = ZModelLanguageMetaData2.fileExtensions.join(", ");
@@ -4013,7 +4109,8 @@ function createProgram() {
 Documentation: https://zenstack.dev/docs`).showHelpAfterError().showSuggestionAfterError();
   const schemaOption = new Option("--schema <file>", `schema file (with extension ${schemaExtensions}). Defaults to "zenstack/schema.zmodel" unless specified in package.json.`);
   const noVersionCheckOption = new Option("--no-version-check", "do not check for new version");
-  program.command("generate").description("Run code generation plugins").addOption(schemaOption).addOption(noVersionCheckOption).addOption(new Option("-o, --output <path>", "default output directory for code generation")).addOption(new Option("-w, --watch", "enable watch mode").default(false)).addOption(new Option("--lite", "also generate a lite version of schema without attributes").default(false)).addOption(new Option("--lite-only", "only generate lite version of schema without attributes").default(false)).addOption(new Option("--silent", "suppress all output except errors").default(false)).action(generateAction);
+  const noTipsOption = new Option("--no-tips", "do not show usage tips");
+  program.command("generate").description("Run code generation plugins").addOption(schemaOption).addOption(noVersionCheckOption).addOption(noTipsOption).addOption(new Option("-o, --output <path>", "default output directory for code generation")).addOption(new Option("-w, --watch", "enable watch mode").default(false)).addOption(triStateBooleanOption("--lite [boolean]", "also generate a lite version of schema without attributes, defaults to false")).addOption(triStateBooleanOption("--lite-only [boolean]", "only generate lite version of schema without attributes, defaults to false")).addOption(triStateBooleanOption("--generate-models [boolean]", "generate models.ts file, defaults to true")).addOption(triStateBooleanOption("--generate-input [boolean]", "generate input.ts file, defaults to true")).addOption(new Option("--silent", "suppress all output except errors").default(false)).action(generateAction);
   const migrateCommand = program.command("migrate").description("Run database schema migration related tasks.");
   const migrationsOption = new Option("--migrations <path>", 'path that contains the "migrations" directory');
   migrateCommand.command("dev").addOption(schemaOption).addOption(noVersionCheckOption).addOption(new Option("-n, --name <name>", "migration name")).addOption(new Option("--create-only", "only create migration, do not apply")).addOption(migrationsOption).description("Create a migration from changes in schema and apply it to the database").action((options) => migrateAction("dev", options));