@orizm/cli 0.1.0 → 1.0.0

package/dist/cli.js

@@ -1,3 +1,4 @@
+"use strict";
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -36,10 +37,15 @@ async function loadConfig(configFile) {
     entryPoints: [configFile],
     bundle: true,
     write: false,
-    format: "cjs",
-    target: "node16"
+    format: "esm",
+    target: "node16",
+    platform: "node"
   });
-  return v.parse(import_config_validator.OrizmConfigDef, eval(buildResult.outputFiles[0].text).default);
+  const moduleURL = `data:text/javascript,${encodeURIComponent(
+    buildResult.outputFiles[0].text
+  )}`;
+  const { default: orizmConfigRaw } = await import(moduleURL);
+  return v.parse(import_config_validator.OrizmConfigDef, orizmConfigRaw);
 }
 
 // src/lib/cli-spinner.ts
@@ -271,7 +277,6 @@ var cmsGenerateCommand = new import_commander.Command("generate").description("g
 
 // src/cms/pull/command.ts
 var import_commander2 = require("commander");
-var cliColor2 = __toESM(require("cli-color"));
 
 // src/api/developer-api-client.ts
 var import_openapi_fetch = __toESM(require("openapi-fetch"));
@@ -286,33 +291,48 @@ function createDeveloperAPIClient(baseUrl, apiKey) {
   });
 }
 
-// src/cms/pull/fetch-definition-reference.ts
+// src/lib/fetch-definition-reference.ts
 async function fetchDefinitionReference(options) {
   const client = createDeveloperAPIClient(options.baseUrl, options.apiKey);
-  const response = await client.GET(
-    "/projects/{projectName}/definitions/current/reference",
-    {
-      params: { path: { projectName: options.projectName } }
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => {
+    abortController.abort();
+  }, 1e4);
+  try {
+    const response = await client.GET(
+      "/projects/{projectName}/definitions/current/reference",
+      {
+        params: { path: { projectName: options.projectName } },
+        signal: abortController.signal
+      }
+    );
+    if (response.data) {
+      return response.data.content;
     }
-  );
-  if (response.data) {
-    return response.data.content;
-  }
-  if (response.response.status === 404) {
-    throw new Error(`Project ${options.projectName} not found.`);
-  }
-  if (response.response.status === 401) {
-    throw new Error(`API Key is invalid.`);
+    if (response.response.status === 404) {
+      throw new Error(`Project ${options.projectName} not found.`);
+    }
+    if (response.response.status === 401) {
+      throw new Error(`API Key is invalid.`);
+    }
+    throw new Error(
+      `Unknown error occurred when fetching definitions for project ${options.projectName}.`
+    );
+  } catch (error2) {
+    if (error2 instanceof Error && error2.name === "AbortError") {
+      throw new Error("Request timed out.");
+    }
+    throw error2;
+  } finally {
+    clearTimeout(timeout);
   }
-  throw new Error(
-    `Unknown error occurred when fetching definitions for project ${options.projectName}.`
-  );
 }
 
-// src/cms/pull/load-env.ts
+// src/lib/load-env.ts
 var import_promises2 = __toESM(require("fs/promises"));
 var v3 = __toESM(require("valibot"));
 var import_dotenv = __toESM(require("dotenv"));
+var DEFAULT_ENV_FILE_PATH = ".env";
 var EnvSchema = v3.object({
   ORIZM_PROJECT: v3.pipe(
     v3.string(),
@@ -333,22 +353,41 @@ var EnvSchema = v3.object({
   )
 });
 async function loadEnv(envPath) {
-  const envFileContent = await import_promises2.default.readFile(envPath, "utf-8");
-  const dotenvParsed = import_dotenv.default.parse(envFileContent);
-  const envParseResult = v3.safeParse(EnvSchema, dotenvParsed);
-  if (!envParseResult.success) {
+  let envFileContent;
+  if (envPath) {
+    envFileContent = await import_promises2.default.readFile(envPath, "utf-8").catch(() => null);
+    if (!envFileContent) {
+      throw new Error(`Environment variables file: '${envPath}' is not found.`);
+    }
+  } else {
+    envFileContent = await import_promises2.default.readFile(DEFAULT_ENV_FILE_PATH, "utf-8").catch(() => null);
+  }
+  if (envFileContent !== null) {
+    const dotenvParsed = import_dotenv.default.parse(envFileContent);
+    const envParseResult = v3.safeParse(EnvSchema, dotenvParsed);
+    if (!envParseResult.success) {
+      throw new Error(
+        `Environment variables are not valid.
+` + envParseResult.issues.map((issue) => issue.message).join("\n")
+      );
+    }
+    return envParseResult.output;
+  }
+  const processEnvParseResult = v3.safeParse(EnvSchema, process.env);
+  if (!processEnvParseResult.success) {
     throw new Error(
-      `Environment variables are not valid. ${envParseResult.issues.map((issue) => `${issue.message}(at ${issue.path})`).join("\n")}`
+      "Environment variables are not valid. Put .env file or set environment variables in process.env.\n" + processEnvParseResult.issues.map((issue) => issue.message).join("\n")
     );
   }
-  const env = envParseResult.output;
-  return env;
+  return processEnvParseResult.output;
 }
 
 // src/cms/pull/action.ts
 var spinner2 = createSpinner();
 async function pullAction(options) {
+  spinner2.start("Loading environment variables...");
   const env = await loadEnv(options.envPath);
+  spinner2.succeed("Loaded environment variables.");
   spinner2.start("Loading project schema...");
   const definitionReference = await fetchDefinitionReference({
     baseUrl: env.ORIZM_BASE_URL,
@@ -365,32 +404,24 @@ async function pullAction(options) {
 }
 
 // src/cms/pull/command.ts
-var cmsPullCommand = new import_commander2.Command("pull").description("pull orizm schema and generate client and types.").option("-e, --env <path>", "env file path.", ".env.x.local").option("-o, --output <path>", "output directory.", "./src/orizm").action(async (options) => {
+var cmsPullCommand = new import_commander2.Command("pull").description("pull orizm schema and generate client and types.").option("-e, --env [path]", "env file path.").option("-o, --output <path>", "output directory.", "./src/orizm").action(async (options) => {
   try {
     await pullAction({
       destination: options.output,
       envPath: options.env
     });
   } catch (error2) {
-    if (error2 instanceof Error) {
-      console.error(cliColor2.red("Error:", error2.message));
-      return;
-    }
-    console.error("An unexpected error occurred:", error2);
+    handleError(error2);
   }
 });
 
 // src/consumer/generate/command.ts
 var import_commander3 = require("commander");
 
-// src/consumer/generate/action.ts
-var import_cli_color3 = __toESM(require("cli-color"));
-
 // src/consumer/pull/generate.ts
 var import_promises3 = require("fs/promises");
 var import_path2 = __toESM(require("path"));
 var import_handlebars2 = __toESM(require("handlebars"));
-var import_cli_color2 = __toESM(require("cli-color"));
 
 // src/consumer/templates/client.ts.hbr
 var client_ts_default2 = '//  This file was automatically generated and should not be edited.\n\nimport { ConsumerClientOptions, OrizmConsumerClientBase } from "@orizm/consumer-sdk";\nimport * as Models from "./types";\n\nexport class OrizmClient extends OrizmConsumerClientBase {\n  constructor(options: ConsumerClientOptions) {\n    super(options);\n  }\n\n  readonly tables = {\n    {{#each tables}}\n    {{toEndpointName this.name}}: this.getTableClient<Models.{{toCodeTypeName this.name}}__Descriptor>("{{toEndpointName this.name}}"),\n    {{/each}}\n  };\n}\n';
@@ -400,11 +431,9 @@ var types_ts_default2 = '//  This file was automatically generated and should no
 
 // src/consumer/pull/generate.ts
 async function generate2(options) {
-  console.log("generating ....");
   await (0, import_promises3.mkdir)(options.output, { recursive: true });
   await renderTypes2(options.definition, options.output);
   await renderClient2(options.definition, options.output);
-  console.log("output to: ", options.output, " :", import_cli_color2.default.green("OK"));
 }
 import_handlebars2.default.registerHelper("toEndpointName", (str) => {
   return str;
@@ -451,9 +480,12 @@ import_handlebars2.default.registerHelper("includeType", (column) => {
   if (column.type === "module-array" && column.moduleName)
     return `_ArrayModuleRef<${toCodeTypeName2(column.moduleName)}__Descriptor>`;
 });
-import_handlebars2.default.registerHelper("filterUniqueIndexes", (indexes) => {
-  return (indexes || []).filter((i) => i.unique);
-});
+import_handlebars2.default.registerHelper(
+  "filterUniqueIndexes",
+  (indexes) => {
+    return (indexes || []).filter((i) => i.unique);
+  }
+);
 import_handlebars2.default.registerHelper(
   "getIndexColumns",
   (table, index) => {
@@ -478,246 +510,120 @@ async function renderClient2(config, output) {
 }
 
 // src/consumer/generate/action.ts
+var spinner3 = createSpinner();
 async function generateAction(orizmConfigTs, destination) {
-  try {
-    const definition = await loadConfig(orizmConfigTs);
-    console.log(`definition: ${orizmConfigTs}`);
-    await generate2({
-      definition,
-      output: destination
-    });
-  } catch (e) {
-    console.error(import_cli_color3.default.red(e));
-    process.exit(1);
-  }
+  spinner3.start("Loading project schema...");
+  const definition = await loadConfig(orizmConfigTs);
+  spinner3.succeed("Loaded project schema.");
+  spinner3.start("Generating code...");
+  await generate2({
+    definition,
+    output: destination
+  });
+  spinner3.succeed(`Generated code to '${destination}'`);
 }
 
 // src/consumer/generate/command.ts
 var consumerGenerateCommand = new import_commander3.Command("generate").description("generate orizm client and types.").option("-c, --config <path>", "orizm config file path.", "orizm.config.ts").option("-o, --output <path>", "output directory.", "./src/orizm").action(async (options) => {
-  await generateAction(options.config, options.output);
+  try {
+    await generateAction(options.config, options.output);
+  } catch (error2) {
+    handleError(error2);
+  }
 });
 
 // src/consumer/pull/command.ts
 var import_commander4 = require("commander");
 
 // src/consumer/pull/action.ts
-var import_cli_color5 = __toESM(require("cli-color"));
-
-// src/consumer/pull/pull.ts
-var import_cli_color4 = __toESM(require("cli-color"));
-async function pullDefinition(config) {
-  console.log("pull definition ....");
-  const abortController = new AbortController();
-  const abortTimer = setTimeout(() => {
-    abortController.abort();
-  }, 1e4);
-  try {
-    const url = new URL(config.baseUrl);
-    url.pathname = `/api/consumer/v1/${config.projectName}/definitions/current`;
-    const response = await fetch(url, {
-      headers: {
-        "x-consumer-key": config.consumerKey,
-        "User-Agent": "orizm-consumer-cli"
-      },
-      signal: abortController.signal
-    });
-    if (response.ok) {
-      const definition = await response.json().then((data) => data.content);
-      console.log(
-        `definitionVersion: ${definition.definitionVersion}`,
-        import_cli_color4.default.green("OK")
-      );
-      return definition;
-    } else {
-      throw new Error(
-        `Failed to pull definition : status code ${response.status}
-${response.statusText}`
-      );
-    }
-  } catch (e) {
-    if (e instanceof TypeError || e instanceof DOMException && e.name === "AbortError") {
-      throw new Error("Failed to pull definition: " + String(e));
-    }
-    throw e;
-  } finally {
-    clearTimeout(abortTimer);
-  }
-}
-
-// src/consumer/pull/config.ts
-var import_fs = require("fs");
-var import_dotenv2 = require("dotenv");
-async function loadConfig2(configPath) {
-  const config = (() => {
-    if ((0, import_fs.existsSync)(configPath)) {
-      const env = (0, import_fs.readFileSync)(configPath);
-      return (0, import_dotenv2.parse)(env);
-    } else {
-      return {};
-    }
-  })();
-  const projectName = config.ORIZM_PROJECT_NAME || process.env.ORIZM_PROJECT_NAME;
-  const consumerKey = config.ORIZM_CONSUMER_KEY || process.env.ORIZM_CONSUMER_KEY;
-  const baseUrl = config.ORIZM_BASE_URL || process.env.ORIZM_BASE_URL || "https://app.orizm.com";
-  console.log(`ORIZM_BASE_URL    : ${baseUrl}`);
-  console.log(`ORIZM_PROJECT_NAME: ${projectName}`);
-  console.log(`ORIZM_CONSUMER_KEY: ${consumerKey ? "****" : void 0}`);
-  if (!projectName || !consumerKey) {
-    const errors = [];
-    if (!projectName) {
-      errors.push(
-        "ORIZM_CONSUMER_KEY is not set. Please set ORIZM_CONSUMER_KEY in .env.x-consumer-cli.local or environment variable."
-      );
-    }
-    if (!consumerKey) {
-      errors.push(
-        "ORIZM_PROJECT_NAME is not set. Please set ORIZM_PROJECT_NAME in .env.x-consumer-cli.local or environment variable."
-      );
-    }
-    throw new Error(errors.join("\n"));
-  }
-  return {
-    projectName,
-    consumerKey,
-    baseUrl
-  };
+var spinner4 = createSpinner();
+async function pullAction2(options) {
+  spinner4.start("Loading environment variables...");
+  const config = await loadEnv(options.envPath);
+  spinner4.succeed("Loaded environment variables.");
+  spinner4.start("Loading project schema...");
+  const definition = await fetchDefinitionReference({
+    baseUrl: config.ORIZM_BASE_URL,
+    apiKey: config.ORIZM_API_KEY,
+    projectName: config.ORIZM_PROJECT
+  });
+  spinner4.succeed("Loaded project schema.");
+  spinner4.start("Generating code...");
+  await generate2({
+    definition,
+    output: options.destination
+  });
+  spinner4.succeed(`Generated code to '${options.destination}'`);
 }
 
-// src/consumer/pull/action.ts
-async function pullAction2(options) {
+// src/consumer/pull/command.ts
+var consumerPullCommand = new import_commander4.Command("pull").description("pull orizm schema and generate client and types.").option("-e, --env [path]", "env file path.").option("-o, --output <path>", "output directory.", "./src/orizm").action(async (options) => {
   try {
-    const config = await loadConfig2(options.envPath);
-    const definition = await pullDefinition(config);
-    await generate2({
-      definition,
-      output: options.destination
+    await pullAction2({
+      destination: options.output,
+      envPath: options.env
     });
-  } catch (e) {
-    console.error(import_cli_color5.default.red(e));
-    process.exit(1);
+  } catch (error2) {
+    handleError(error2);
   }
-}
-
-// src/consumer/pull/command.ts
-var consumerPullCommand = new import_commander4.Command("pull").description("pull orizm schema and generate client and types.").option("-e, --env <path>", "env file path.", ".env.x-consumer-cli.local").option("-o, --output <path>", "output directory.", "./src/orizm").action(async (options) => {
-  await pullAction2({
-    destination: options.output,
-    envPath: options.env
-  });
 });
 
 // src/push/command.ts
 var import_commander5 = require("commander");
-var import_cli_color7 = require("cli-color");
-
-// src/lib/env-manager.ts
-var import_fs2 = __toESM(require("fs"));
-var import_dotenv3 = __toESM(require("dotenv"));
-var import_valibot = require("valibot");
-var defaultEnvFilePath = ".env.x.local";
-var schema = (0, import_valibot.object)({
-  ORIZM_PROJECT: (0, import_valibot.pipe)(
-    (0, import_valibot.string)(),
-    (0, import_valibot.minLength)(1, "ORIZM_PROJECT is required"),
-    (0, import_valibot.brand)("ORIZM_PROJECT")
-  ),
-  ORIZM_BASE_URL: (0, import_valibot.pipe)(
-    (0, import_valibot.nullish)((0, import_valibot.string)(), "https://app.orizm.com"),
-    // if null, use default value
-    (0, import_valibot.transform)((v4) => v4.replace(/\/$/, "")),
-    // remove trailing slash
-    (0, import_valibot.brand)("ORIZM_BASE_URL")
-  ),
-  ORIZM_API_KEY: (0, import_valibot.pipe)(
-    (0, import_valibot.string)(),
-    (0, import_valibot.minLength)(1, "ORIZM_API_KEY is required"),
-    (0, import_valibot.brand)("ORIZM_API_KEY")
-  )
-});
-var EnvManager = class {
-  parsed;
-  constructor(envFilePath) {
-    if (envFilePath && import_fs2.default.existsSync(envFilePath)) {
-      import_dotenv3.default.config({ path: envFilePath });
-    } else if (envFilePath !== defaultEnvFilePath) {
-      throw new Error(
-        `environment variables file: '${envFilePath}' is not found.`
-      );
-    } else {
-      import_dotenv3.default.config();
-    }
-    const result = (0, import_valibot.parse)(schema, process.env);
-    this.parsed = result;
-  }
-  get projectName() {
-    return this.parsed.ORIZM_PROJECT;
-  }
-  get baseUrl() {
-    return this.parsed.ORIZM_BASE_URL;
-  }
-  get apiKey() {
-    return this.parsed.ORIZM_API_KEY;
-  }
-};
+var import_cli_color3 = require("cli-color");
 
 // src/lib/developer-api.ts
-async function request(props) {
-  return await fetch(`${props.env.baseUrl}/api/dev/v1${props.path}`, {
-    method: props.method,
-    headers: {
-      "content-type": "application/json",
-      "x-api-key": props.env.apiKey
-    },
-    body: JSON.stringify(props.body)
-  });
-}
 async function applyDefinition(env, projectDef) {
-  const response = await request({
-    env,
-    method: "POST",
-    path: `/projects/${env.projectName}/definitions`,
+  const client = createDeveloperAPIClient(
+    env.ORIZM_BASE_URL,
+    env.ORIZM_API_KEY
+  );
+  const response = await client.POST("/projects/{projectName}/definitions", {
+    params: { path: { projectName: env.ORIZM_PROJECT } },
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     body: { apply: true, project: projectDef }
   });
-  if (!response.ok) {
-    const status = response.status;
+  if (!response.data) {
+    const status = response.response.status;
     if (status === 401) {
       throw new Error(
         "401 Unauthorized. Please check your Developer API key and try again."
       );
     }
     throw new Error(
-      `${status} ${response.statusText}: Occurred unexpected error.`
+      `${status} ${response.response.statusText}: Unexpected error occurred while applying schema.`
     );
   }
 }
 var getChangeEvents = async (env, projectDef) => {
-  const response = await request({
-    env,
-    method: "POST",
-    path: `/projects/${env.projectName}/definitions/dry-run`,
-    body: { project: projectDef }
-  });
-  if (!response.ok) {
-    const status = response.status;
-    if (status === 400) {
-      const body = await response.json();
-      throw new Error(`400 Bad Request:
-${JSON.stringify(body, null, 2)}`);
+  const client = createDeveloperAPIClient(
+    env.ORIZM_BASE_URL,
+    env.ORIZM_API_KEY
+  );
+  const response = await client.POST(
+    "/projects/{projectName}/definitions/dry-run",
+    {
+      params: { path: { projectName: env.ORIZM_PROJECT } },
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      body: { project: projectDef }
     }
+  );
+  if (!response.data) {
+    const status = response.response.status;
     if (status === 401) {
       throw new Error(
-        "401 Unauthorized: Please check your Developer API key and try again."
+        "401 Unauthorized. Please check your Developer API key and try again."
       );
     }
     throw new Error(
-      `${status} ${response.statusText}: Occurred unexpected error.`
+      `${status} ${response.response.statusText}: Unexpected error occurred while fetching schema change events.`
     );
   }
-  return await response.json();
+  return response.data;
 };
 
 // src/lib/display-change-events.ts
-var import_cli_color6 = require("cli-color");
+var import_cli_color2 = require("cli-color");
 
 // src/lib/cli-table.ts
 var COLORS = {
@@ -819,10 +725,23 @@ var CliTable = class {
 
 // src/lib/display-change-events.ts
 async function displayChangeEvents(changeEvents) {
-  const tableChangeEvents = changeEvents.tableChangeEvents ?? [];
-  if (tableChangeEvents.length === 0) {
+  const {
+    tableChangeEvents = [],
+    bucketChangeEvents = [],
+    authorityChangeEvents = []
+  } = changeEvents;
+  if (tableChangeEvents.length === 0 && bucketChangeEvents.length === 0 && authorityChangeEvents.length === 0) {
     console.log();
-    console.log((0, import_cli_color6.green)("No changes."));
+    console.log((0, import_cli_color2.green)("No changes."));
+    return;
+  }
+  displayTableChangeEvents(tableChangeEvents);
+  displayBucketChangeEvents(bucketChangeEvents);
+  displayAuthorityChangeEvents(authorityChangeEvents);
+  console.log();
+}
+function displayTableChangeEvents(tableChangeEvents) {
+  if (tableChangeEvents.length === 0) {
     return;
   }
   const eventsByTable = /* @__PURE__ */ new Map();
@@ -974,9 +893,81 @@ async function displayChangeEvents(changeEvents) {
       }
     }
     table.print();
-    console.log();
   }
 }
+function displayBucketChangeEvents(bucketChangeEvents) {
+  if (bucketChangeEvents.length === 0) {
+    return;
+  }
+  const eventsByBucket = /* @__PURE__ */ new Map();
+  for (const event of bucketChangeEvents) {
+    const bucketName = event.bucketDef.name;
+    const bucketEvents = eventsByBucket.get(bucketName) ?? [];
+    bucketEvents.push(event);
+    eventsByBucket.set(bucketName, bucketEvents);
+  }
+  const table = new CliTable(["Type", "Name", "Event", "Detail"]);
+  console.log();
+  console.log("\u26AB\uFE0EBuckets");
+  for (const [_, events] of eventsByBucket.entries()) {
+    for (const event of events) {
+      const eventName = event.event;
+      switch (eventName) {
+        case "bucket:create":
+        case "bucket:update": {
+          table.addRow(
+            [
+              "bucket",
+              event.bucketDef.name,
+              eventName,
+              JSON.stringify(event.bucketDef)
+            ],
+            {
+              color: "green"
+            }
+          );
+          break;
+        }
+        case "bucket:delete": {
+          table.addRow(
+            [
+              "bucket",
+              event.bucketDef.name,
+              eventName,
+              JSON.stringify(event.bucketDef)
+            ],
+            {
+              color: "red"
+            }
+          );
+          break;
+        }
+      }
+    }
+  }
+  table.print();
+}
+function displayAuthorityChangeEvents(authorityChangeEvents) {
+  if (authorityChangeEvents.length === 0) {
+    return;
+  }
+  const table = new CliTable(["Type", "Event", "Detail"]);
+  console.log();
+  console.log("\u26AB\uFE0EAuthorities");
+  for (const event of authorityChangeEvents) {
+    const eventName = event.event;
+    switch (eventName) {
+      case "authority:update": {
+        table.addRow(
+          ["authority", eventName, JSON.stringify(event.authorityDef)],
+          { color: "green" }
+        );
+        break;
+      }
+    }
+  }
+  table.print();
+}
 
 // src/lib/cli-input.ts
 var import_promises4 = require("readline/promises");
@@ -992,20 +983,20 @@ async function input(prompt) {
 }
 
 // src/push/command.ts
-var spinner3 = createSpinner();
-var pushCommand = new import_commander5.Command("push").description("apply schema to project.").option("-e, --env <path>", "env file path.", ".env.x.local").option("-c, --config <path>", "orizm config file path.", "orizm.config.ts").option("--dry-run", "display change-events without applying schema.", false).option("-y, --yes", "apply schema without confirmation.", false).action(async (options) => {
+var spinner5 = createSpinner();
+var pushCommand = new import_commander5.Command("push").description("apply schema to project.").option("-e, --env <path>", "env file path.").option("-c, --config <path>", "orizm config file path.", "orizm.config.ts").option("--dry-run", "display change-events without applying schema.", false).option("-y, --yes", "apply schema without confirmation.", false).action(async (options) => {
   try {
-    spinner3.start("Loading environment variables...");
-    const env = new EnvManager(options.env);
-    spinner3.succeed("Loaded environment variables.");
-    spinner3.start("Loading project schema...");
+    spinner5.start("Loading environment variables...");
+    const env = await loadEnv(options.env);
+    spinner5.succeed("Loaded environment variables.");
+    spinner5.start("Loading project schema...");
     const projectDef = await loadConfig(options.config);
-    spinner3.succeed("Loaded project schema.");
-    spinner3.start("Fetch schema change events...");
+    spinner5.succeed("Loaded project schema.");
+    spinner5.start("Fetch schema change events...");
     const changeEvents = await getChangeEvents(env, projectDef);
-    spinner3.succeed("Fetch schema change events.");
+    spinner5.succeed("Fetch schema change events.");
     await displayChangeEvents(changeEvents);
-    if (changeEvents.tableChangeEvents.length === 0) {
+    if (changeEvents.tableChangeEvents.length === 0 && changeEvents.bucketChangeEvents.length === 0 && changeEvents.authorityChangeEvents.length === 0) {
       return;
     }
     if (options.dryRun) {
@@ -1014,13 +1005,13 @@ var pushCommand = new import_commander5.Command("push").description("apply schem
     if (!options.yes) {
       const confirm = await input("Do you want to apply schema? (y/N): ");
       if (confirm !== "y") {
-        console.log((0, import_cli_color7.red)("Canceled."));
+        console.log((0, import_cli_color3.red)("Canceled."));
         return;
       }
     }
-    spinner3.start("Applying schema...");
+    spinner5.start("Applying schema...");
     await applyDefinition(env, projectDef);
-    spinner3.succeed("Schema applied.");
+    spinner5.succeed("Schema applied.");
   } catch (error2) {
     handleError(error2);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orizm/cli",
-  "version": "0.1.0",
+  "version": "1.0.0",
   "description": "Orizm CLI",
   "repository": {
     "type": "git",
@@ -19,7 +19,7 @@
     "handlebars": "^4.7.7",
     "openapi-fetch": "^0.12.2",
     "valibot": "^1.0.0",
-    "@orizm/common": "1.11.0"
+    "@orizm/common": "1.12.0"
   },
   "bin": {
     "orizm": "bin/index.js"
@@ -31,6 +31,7 @@
   },
   "license": "Apache-2.0",
   "scripts": {
+    "dev": "tsup --watch",
     "build": "tsup",
     "typecheck": "tsc --noEmit",
     "generate": "openapi-typescript ../../apps/server/openapi/developerAPI.yaml --output src/api/developer-api.d.ts"