@zenstackhq/cli 3.0.0-alpha.0

package/.turbo/turbo-build.log

@@ -0,0 +1,23 @@
+
+
+> @zenstackhq/cli@3.0.0-alpha.1 build /Users/yiming/git/zenstack/zenstack-v3/packages/cli
+> tsup-node
+
+CLI Building entry: {"index":"src/index.ts"}
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.3.5
+CLI Using tsup config: /Users/yiming/git/zenstack/zenstack-v3/packages/cli/tsup.config.ts
+CLI Target: esnext
+CLI Cleaning output folder
+ESM Build start
+CJS Build start
+ESM dist/index.js     14.02 KB
+ESM dist/index.js.map 27.76 KB
+ESM ⚡️ Build success in 51ms
+CJS dist/index.cjs     15.95 KB
+CJS dist/index.cjs.map 27.84 KB
+CJS ⚡️ Build success in 51ms
+DTS Build start
+DTS ⚡️ Build success in 1226ms
+DTS dist/index.d.ts  108.00 B
+DTS dist/index.d.cts 108.00 B

package/.turbo/turbo-lint.log

@@ -0,0 +1,18 @@
+
+
+> zenstack@3.0.0-alpha.1 lint /Users/yiming/git/zenstack/zenstack-v3/packages/cli
+> eslint src --ext ts
+
+=============
+
+WARNING: You are currently running a version of TypeScript which is not officially supported by @typescript-eslint/typescript-estree.
+
+You may find that it works just fine, or you may not.
+
+SUPPORTED TYPESCRIPT VERSIONS: >=4.7.4 <5.5.0
+
+YOUR TYPESCRIPT VERSION: 5.7.3
+
+Please only submit bug reports when using the officially supported version.
+
+=============

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ZenStack
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/cli

@@ -0,0 +1,3 @@
+#!/usr/bin/env node --no-warnings
+
+import '../dist/index.js';

package/dist/index.cjs

@@ -0,0 +1,543 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// package.json
+var require_package = __commonJS({
+  "package.json"(exports2, module2) {
+    module2.exports = {
+      name: "@zenstackhq/cli",
+      publisher: "zenstack",
+      displayName: "ZenStack CLI",
+      description: "FullStack database toolkit with built-in access control and automatic API generation.",
+      version: "3.0.0-alpha.0",
+      type: "module",
+      author: {
+        name: "ZenStack Team"
+      },
+      homepage: "https://zenstack.dev",
+      license: "MIT",
+      keywords: [
+        "orm",
+        "fullstack",
+        "react",
+        "typescript",
+        "data modeling"
+      ],
+      bin: {
+        zenstack: "bin/cli"
+      },
+      scripts: {
+        build: "tsup-node",
+        watch: "tsup-node --watch",
+        lint: "eslint src --ext ts",
+        test: "vitest",
+        pack: "pnpm pack"
+      },
+      dependencies: {
+        "@types/node": "^20.0.0",
+        "@zenstackhq/language": "workspace:*",
+        "@zenstackhq/sdk": "workspace:*",
+        "async-exit-hook": "^2.0.1",
+        colors: "1.4.0",
+        commander: "^8.3.0",
+        langium: "~3.3.0",
+        ora: "^5.4.1",
+        "package-manager-detector": "^1.3.0",
+        "tiny-invariant": "^1.3.3",
+        "ts-pattern": "^4.3.0"
+      },
+      peerDependencies: {
+        prisma: "^6.0.0",
+        typescript: "^5.0.0"
+      },
+      devDependencies: {
+        "@types/async-exit-hook": "^2.0.0",
+        "@types/better-sqlite3": "^7.6.13",
+        "@types/semver": "^7.3.13",
+        "@types/tmp": "^0.2.6",
+        "@zenstackhq/runtime": "workspace:*",
+        "@zenstackhq/testtools": "workspace:*",
+        "better-sqlite3": "^11.8.1",
+        tmp: "^0.2.3"
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  createProgram: () => createProgram
+});
+module.exports = __toCommonJS(src_exports);
+var import_language2 = require("@zenstackhq/language");
+var import_colors5 = __toESM(require("colors"), 1);
+var import_commander = require("commander");
+
+// src/actions/db.ts
+var import_node_path2 = __toESM(require("path"), 1);
+
+// src/utils/exec-utils.ts
+var import_child_process = require("child_process");
+function execSync(cmd, options) {
+  const { env, ...restOptions } = options ?? {};
+  const mergedEnv = env ? {
+    ...process.env,
+    ...env
+  } : void 0;
+  (0, import_child_process.execSync)(cmd, {
+    encoding: "utf-8",
+    stdio: options?.stdio ?? "inherit",
+    env: mergedEnv,
+    ...restOptions
+  });
+}
+__name(execSync, "execSync");
+function execPackage(cmd, options) {
+  const packageManager = process?.versions?.["bun"] ? "bunx" : "npx";
+  execSync(`${packageManager} ${cmd}`, options);
+}
+__name(execPackage, "execPackage");
+
+// src/actions/action-utils.ts
+var import_node_fs = __toESM(require("fs"), 1);
+
+// src/cli-error.ts
+var CliError = class extends Error {
+  static {
+    __name(this, "CliError");
+  }
+};
+
+// src/actions/action-utils.ts
+var import_language = require("@zenstackhq/language");
+var import_colors = __toESM(require("colors"), 1);
+function getSchemaFile(file) {
+  if (file) {
+    if (!import_node_fs.default.existsSync(file)) {
+      throw new CliError(`Schema file not found: ${file}`);
+    }
+    return file;
+  }
+  if (import_node_fs.default.existsSync("./zenstack/schema.zmodel")) {
+    return "./zenstack/schema.zmodel";
+  } else if (import_node_fs.default.existsSync("./schema.zmodel")) {
+    return "./schema.zmodel";
+  } else {
+    throw new CliError('Schema file not found in default locations ("./zenstack/schema.zmodel" or "./schema.zmodel").');
+  }
+}
+__name(getSchemaFile, "getSchemaFile");
+async function loadSchemaDocument(schemaFile) {
+  const loadResult = await (0, import_language.loadDocument)(schemaFile);
+  if (!loadResult.success) {
+    console.error(import_colors.default.red("Error loading schema:"));
+    loadResult.errors.forEach((err) => {
+      console.error(import_colors.default.red(err));
+    });
+    throw new CliError("Failed to load schema");
+  }
+  return loadResult.model;
+}
+__name(loadSchemaDocument, "loadSchemaDocument");
+function handleSubProcessError(err) {
+  if (err instanceof Error && "status" in err && typeof err.status === "number") {
+    process.exit(err.status);
+  } else {
+    process.exit(1);
+  }
+}
+__name(handleSubProcessError, "handleSubProcessError");
+
+// src/actions/generate.ts
+var import_ast = require("@zenstackhq/language/ast");
+var import_sdk = require("@zenstackhq/sdk");
+var import_colors2 = __toESM(require("colors"), 1);
+var import_node_fs2 = __toESM(require("fs"), 1);
+var import_node_path = __toESM(require("path"), 1);
+var import_tiny_invariant = __toESM(require("tiny-invariant"), 1);
+async function run(options) {
+  const schemaFile = getSchemaFile(options.schema);
+  const model = await loadSchemaDocument(schemaFile);
+  const outputPath = options.output ?? import_node_path.default.dirname(schemaFile);
+  const tsSchemaFile = import_node_path.default.join(outputPath, "schema.ts");
+  await new import_sdk.TsSchemaGenerator().generate(schemaFile, [], tsSchemaFile);
+  await runPlugins(model, outputPath, tsSchemaFile);
+  const prismaSchema = await new import_sdk.PrismaSchemaGenerator(model).generate();
+  import_node_fs2.default.writeFileSync(import_node_path.default.join(outputPath, "schema.prisma"), prismaSchema);
+  if (!options.silent) {
+    console.log(import_colors2.default.green("Generation completed successfully."));
+    console.log(`You can now create a ZenStack client with it.
+
+\`\`\`
+import { ZenStackClient } from '@zenstackhq/runtime';
+import { schema } from '${outputPath}/schema';
+
+const client = new ZenStackClient(schema);
+\`\`\`
+`);
+  }
+}
+__name(run, "run");
+async function runPlugins(model, outputPath, tsSchemaFile) {
+  const plugins = model.declarations.filter(import_ast.isPlugin);
+  for (const plugin of plugins) {
+    const providerField = plugin.fields.find((f) => f.name === "provider");
+    (0, import_tiny_invariant.default)(providerField, `Plugin ${plugin.name} does not have a provider field`);
+    const provider = providerField.value.value;
+    let useProvider = provider;
+    if (useProvider.startsWith("@core/")) {
+      useProvider = `@zenstackhq/runtime/plugins/${useProvider.slice(6)}`;
+    }
+    const generator = (await import(useProvider)).default;
+    console.log("Running generator:", provider);
+    await generator({
+      model,
+      outputPath,
+      tsSchemaFile
+    });
+  }
+}
+__name(runPlugins, "runPlugins");
+
+// src/actions/db.ts
+async function run2(command, options) {
+  const schemaFile = getSchemaFile(options.schema);
+  await run({
+    schema: schemaFile,
+    silent: true
+  });
+  const prismaSchemaFile = import_node_path2.default.join(import_node_path2.default.dirname(schemaFile), "schema.prisma");
+  switch (command) {
+    case "push":
+      await runPush(prismaSchemaFile, options);
+      break;
+  }
+}
+__name(run2, "run");
+async function runPush(prismaSchemaFile, options) {
+  const cmd = `prisma db push --schema "${prismaSchemaFile}"${options.acceptDataLoss ? " --accept-data-loss" : ""}${options.forceReset ? " --force-reset" : ""} --skip-generate`;
+  try {
+    await execPackage(cmd, {
+      stdio: "inherit"
+    });
+  } catch (err) {
+    handleSubProcessError(err);
+  }
+}
+__name(runPush, "runPush");
+
+// src/actions/info.ts
+var import_colors3 = __toESM(require("colors"), 1);
+var import_node_path3 = __toESM(require("path"), 1);
+async function run3(projectPath) {
+  const packages = await getZenStackPackages(projectPath);
+  if (!packages) {
+    console.error("Unable to locate package.json. Are you in a valid project directory?");
+    return;
+  }
+  console.log("Installed ZenStack Packages:");
+  const versions = /* @__PURE__ */ new Set();
+  for (const { pkg, version } of packages) {
+    if (version) {
+      versions.add(version);
+    }
+    console.log(`    ${import_colors3.default.green(pkg.padEnd(20))}	${version}`);
+  }
+  if (versions.size > 1) {
+    console.warn(import_colors3.default.yellow("WARNING: Multiple versions of Zenstack packages detected. This may cause issues."));
+  }
+}
+__name(run3, "run");
+async function getZenStackPackages(projectPath) {
+  let pkgJson;
+  const resolvedPath = import_node_path3.default.resolve(projectPath);
+  try {
+    pkgJson = (await import(import_node_path3.default.join(resolvedPath, "package.json"), {
+      with: {
+        type: "json"
+      }
+    })).default;
+  } catch (err) {
+    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;
+      return {
+        pkg,
+        version: depPkgJson.version
+      };
+    } catch {
+      return {
+        pkg,
+        version: void 0
+      };
+    }
+  }));
+  return result;
+}
+__name(getZenStackPackages, "getZenStackPackages");
+
+// src/actions/init.ts
+var import_colors4 = __toESM(require("colors"), 1);
+var import_node_fs3 = __toESM(require("fs"), 1);
+var import_node_path4 = __toESM(require("path"), 1);
+var import_ora = __toESM(require("ora"), 1);
+var import_package_manager_detector = require("package-manager-detector");
+
+// src/actions/templates.ts
+var STARTER_ZMODEL = `// This is a sample model to get you started.
+
+/// A sample data source using local sqlite db.
+datasource db {
+    provider = 'sqlite'
+    url = 'file:./dev.db'
+}
+
+/// User model
+model User {
+    id       String @id @default(cuid())
+    email    String @unique @email @length(6, 32)
+    posts    Post[]
+}
+
+/// Post model
+model Post {
+    id        String   @id @default(cuid())
+    createdAt DateTime @default(now())
+    updatedAt DateTime @updatedAt
+    title     String   @length(1, 256)
+    content   String
+    published Boolean  @default(false)
+    author    User     @relation(fields: [authorId], references: [id])
+    authorId  String
+}
+`;
+
+// src/actions/init.ts
+async function run4(projectPath) {
+  const packages = [
+    {
+      name: "@zenstackhq/cli",
+      dev: true
+    },
+    {
+      name: "@zenstackhq/runtime",
+      dev: false
+    }
+  ];
+  let pm = await (0, import_package_manager_detector.detect)();
+  if (!pm) {
+    pm = {
+      agent: "npm",
+      name: "npm"
+    };
+  }
+  console.log(import_colors4.default.gray(`Using package manager: ${pm.agent}`));
+  for (const pkg of packages) {
+    const resolved = (0, import_package_manager_detector.resolveCommand)(pm.agent, "install", [
+      pkg.name,
+      ...pkg.dev ? [
+        pm.agent === "yarn" ? "--dev" : "--save-dev"
+      ] : []
+    ]);
+    if (!resolved) {
+      throw new CliError(`Unable to determine how to install package "${pkg.name}". Please install it manually.`);
+    }
+    const spinner = (0, import_ora.default)(`Installing "${pkg.name}"`).start();
+    try {
+      execSync(`${resolved.command} ${resolved.args.join(" ")}`, {
+        cwd: projectPath
+      });
+      spinner.succeed();
+    } catch (e) {
+      spinner.fail();
+      throw e;
+    }
+  }
+  const generationFolder = "zenstack";
+  if (!import_node_fs3.default.existsSync(import_node_path4.default.join(projectPath, generationFolder))) {
+    import_node_fs3.default.mkdirSync(import_node_path4.default.join(projectPath, generationFolder));
+  }
+  if (!import_node_fs3.default.existsSync(import_node_path4.default.join(projectPath, generationFolder, "schema.zmodel"))) {
+    import_node_fs3.default.writeFileSync(import_node_path4.default.join(projectPath, generationFolder, "schema.zmodel"), STARTER_ZMODEL);
+  } else {
+    console.log(import_colors4.default.yellow("Schema file already exists. Skipping generation of sample."));
+  }
+  console.log(import_colors4.default.green("ZenStack project initialized successfully!"));
+  console.log(import_colors4.default.gray(`See "${generationFolder}/schema.zmodel" for your database schema.`));
+  console.log(import_colors4.default.gray("Run `zenstack generate` to compile the the schema into a TypeScript file."));
+}
+__name(run4, "run");
+
+// src/actions/migrate.ts
+var import_node_path5 = __toESM(require("path"), 1);
+async function run5(command, options) {
+  const schemaFile = getSchemaFile(options.schema);
+  await run({
+    schema: schemaFile,
+    silent: true
+  });
+  const prismaSchemaFile = import_node_path5.default.join(import_node_path5.default.dirname(schemaFile), "schema.prisma");
+  switch (command) {
+    case "dev":
+      await runDev(prismaSchemaFile, options);
+      break;
+    case "reset":
+      await runReset(prismaSchemaFile, options);
+      break;
+    case "deploy":
+      await runDeploy(prismaSchemaFile, options);
+      break;
+    case "status":
+      await runStatus(prismaSchemaFile, options);
+      break;
+  }
+}
+__name(run5, "run");
+async function runDev(prismaSchemaFile, _options) {
+  try {
+    await execPackage(`prisma migrate dev --schema "${prismaSchemaFile}" --skip-generate`, {
+      stdio: "inherit"
+    });
+  } catch (err) {
+    handleSubProcessError2(err);
+  }
+}
+__name(runDev, "runDev");
+async function runReset(prismaSchemaFile, options) {
+  try {
+    await execPackage(`prisma migrate reset --schema "${prismaSchemaFile}"${options.force ? " --force" : ""}`, {
+      stdio: "inherit"
+    });
+  } catch (err) {
+    handleSubProcessError2(err);
+  }
+}
+__name(runReset, "runReset");
+async function runDeploy(prismaSchemaFile, _options) {
+  try {
+    await execPackage(`prisma migrate deploy --schema "${prismaSchemaFile}"`, {
+      stdio: "inherit"
+    });
+  } catch (err) {
+    handleSubProcessError2(err);
+  }
+}
+__name(runDeploy, "runDeploy");
+async function runStatus(prismaSchemaFile, _options) {
+  try {
+    await execPackage(`prisma migrate status --schema "${prismaSchemaFile}"`, {
+      stdio: "inherit"
+    });
+  } catch (err) {
+    handleSubProcessError2(err);
+  }
+}
+__name(runStatus, "runStatus");
+function handleSubProcessError2(err) {
+  if (err instanceof Error && "status" in err && typeof err.status === "number") {
+    process.exit(err.status);
+  } else {
+    process.exit(1);
+  }
+}
+__name(handleSubProcessError2, "handleSubProcessError");
+
+// src/utils/version-utils.ts
+function getVersion() {
+  try {
+    return require("../package.json").version;
+  } catch {
+    try {
+      return require_package().version;
+    } catch {
+      return void 0;
+    }
+  }
+}
+__name(getVersion, "getVersion");
+
+// src/index.ts
+var generateAction = /* @__PURE__ */ __name(async (options) => {
+  await run(options);
+}, "generateAction");
+var migrateAction = /* @__PURE__ */ __name(async (command, options) => {
+  await run5(command, options);
+}, "migrateAction");
+var dbAction = /* @__PURE__ */ __name(async (command, options) => {
+  await run2(command, options);
+}, "dbAction");
+var infoAction = /* @__PURE__ */ __name(async (projectPath) => {
+  await run3(projectPath);
+}, "infoAction");
+var initAction = /* @__PURE__ */ __name(async (projectPath) => {
+  await run4(projectPath);
+}, "initAction");
+function createProgram() {
+  const program2 = new import_commander.Command("zenstack");
+  program2.version(getVersion(), "-v --version", "display CLI version");
+  const schemaExtensions = import_language2.ZModelLanguageMetaData.fileExtensions.join(", ");
+  program2.description(`${import_colors5.default.bold.blue("\u03B6")} ZenStack is a Prisma power pack for building full-stack apps.
+
+Documentation: https://zenstack.dev.`).showHelpAfterError().showSuggestionAfterError();
+  const schemaOption = new import_commander.Option("--schema <file>", `schema file (with extension ${schemaExtensions}). Defaults to "schema.zmodel" unless specified in package.json.`);
+  program2.command("generate").description("Run code generation.").addOption(schemaOption).addOption(new import_commander.Option("-o, --output <path>", "default output directory for core plugins")).action(generateAction);
+  const migrateCommand = program2.command("migrate").description("Update the database schema with migrations.");
+  migrateCommand.command("dev").addOption(schemaOption).addOption(new import_commander.Option("-n, --name <name>", "migration name")).addOption(new import_commander.Option("--create-only", "only create migration, do not apply")).description("Create a migration from changes in schema and apply it to the database.").action((options) => migrateAction("dev", options));
+  migrateCommand.command("reset").addOption(schemaOption).addOption(new import_commander.Option("--force", "skip the confirmation prompt")).description("Reset your database and apply all migrations, all data will be lost.").action((options) => migrateAction("reset", options));
+  migrateCommand.command("deploy").addOption(schemaOption).description("Deploy your pending migrations to your production/staging database.").action((options) => migrateAction("deploy", options));
+  migrateCommand.command("status").addOption(schemaOption).description("check the status of your database migrations.").action((options) => migrateAction("status", options));
+  const dbCommand = program2.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(new import_commander.Option("--accept-data-loss", "ignore data loss warnings")).addOption(new import_commander.Option("--force-reset", "force a reset of the database before push")).action((options) => dbAction("push", options));
+  program2.command("info").description("Get information of installed ZenStack and related packages.").argument("[path]", "project path", ".").action(infoAction);
+  program2.command("init").description("Initialize an existing project for ZenStack.").argument("[path]", "project path", ".").action(initAction);
+  return program2;
+}
+__name(createProgram, "createProgram");
+var program = createProgram();
+program.parse(process.argv);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createProgram
+});
+//# sourceMappingURL=index.cjs.map