@orizm/cli 0.1.0

package/LICENSE

@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,9 @@
+# Usage
+
+npm exec orizm-sdk generate -- -i ./orizm.config.ts -o ./src/x/
+
+# For Developer
+
+### Build NPM package
+
+pnpm run build

package/bin/index.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+require("../dist/cli.js");

package/dist/cli.js

@@ -0,0 +1,1042 @@
+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 __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
+));
+
+// src/cli.ts
+var import_commander6 = require("commander");
+
+// src/cms/generate/command.ts
+var import_commander = require("commander");
+
+// src/lib/load-config.ts
+var import_esbuild = __toESM(require("esbuild"));
+var import_config_validator = require("@orizm/common/config-validator");
+var v = __toESM(require("valibot"));
+async function loadConfig(configFile) {
+  const buildResult = await import_esbuild.default.build({
+    entryPoints: [configFile],
+    bundle: true,
+    write: false,
+    format: "cjs",
+    target: "node16"
+  });
+  return v.parse(import_config_validator.OrizmConfigDef, eval(buildResult.outputFiles[0].text).default);
+}
+
+// src/lib/cli-spinner.ts
+var import_readline = __toESM(require("readline"));
+
+// src/lib/cli-symbol.ts
+var import_cli_color = require("cli-color");
+var success = (0, import_cli_color.green)("\u2713");
+var error = (0, import_cli_color.red)("\u2717");
+
+// src/lib/cli-cursor.ts
+function hide() {
+  process.stdout.write("\x1B[?25l");
+}
+function show() {
+  process.stdout.write("\x1B[?25h");
+}
+
+// src/lib/cli-spinner.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var FRAME_INTERVAL = 80;
+var Spinner = class {
+  text = "";
+  currentFrame = 0;
+  timer = null;
+  isSpinning = false;
+  start(text) {
+    if (text) {
+      this.text = text;
+    }
+    if (this.isSpinning) {
+      return this;
+    }
+    this.isSpinning = true;
+    this.currentFrame = 0;
+    hide();
+    this.render();
+    this.timer = setInterval(() => {
+      this.render();
+    }, FRAME_INTERVAL);
+    return this;
+  }
+  stop() {
+    if (!this.isSpinning) {
+      return this;
+    }
+    this.isSpinning = false;
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    import_readline.default.clearLine(process.stdout, 0);
+    import_readline.default.cursorTo(process.stdout, 0);
+    show();
+    return this;
+  }
+  succeed(text) {
+    this.stop();
+    const finalText = text || this.text;
+    console.log(`${success} ${finalText}`);
+  }
+  render() {
+    const frame = FRAMES[this.currentFrame];
+    this.currentFrame = (this.currentFrame + 1) % FRAMES.length;
+    import_readline.default.clearLine(process.stdout, 0);
+    import_readline.default.cursorTo(process.stdout, 0);
+    process.stdout.write(`${frame} ${this.text}`);
+  }
+};
+function createSpinner() {
+  return new Spinner();
+}
+
+// src/lib/handle-error.ts
+var v2 = __toESM(require("valibot"));
+var cliColor = __toESM(require("cli-color"));
+function handleError(error2) {
+  show();
+  if (v2.isValiError(error2)) {
+    console.error();
+    console.error(`Error: ${error2.issues.length} problem(s) found.`);
+    console.error(buildValiErrorMessage(error2));
+    console.error();
+    process.exit(1);
+  }
+  console.error();
+  console.error(
+    cliColor.red(
+      "Something went wrong. Please check the error below for more details."
+    )
+  );
+  console.error();
+  console.error(error2);
+  console.error();
+  process.exit(1);
+}
+function buildValiErrorMessage(e) {
+  return e.issues.map((issue) => {
+    return `  ${cliColor.red(issue.message)} (at ${cliColor.yellow(v2.getDotPath(issue))})`;
+  }).join("\n");
+}
+
+// src/cms/generate/generator.ts
+var import_promises = require("fs/promises");
+var import_path = __toESM(require("path"));
+var import_handlebars = __toESM(require("handlebars"));
+
+// src/cms/templates/types.ts.hbr
+var types_ts_default = '//  This file was automatically generated and should not be edited.\n\nimport { FormValidationRules, StorageItemType } from "@orizm/common";\n\n// Utilities\ntype _ModuleRef<T> = T & _ModuleDescriptor;\ntype _ModuleDescriptor = {\n    isModule: true;\n};\ntype _ArrayModuleRef<T> = T & _ArrayModuleDescriptor;\ntype _ArrayModuleDescriptor = {\n    isModuleArray: true;\n};\n\n// Tables\n{{#each tables}}\nexport type {{toCodeTypeName this.name}} = {\n  id: string;\n  createdAt: string;\n  updatedAt: string;\n  {{#unless this.isSubmissions}}\n  group?: string;\n  publishedAt?: string;\n  _draft?: boolean;\n  _published?: boolean;\n  scheduledPublishAt?: string | null;\n  scheduledUnpublishAt?: string | null;\n  {{else}}\n  _formId: string;\n  _content: unknown;\n  _formSchema: unknown;\n  _attachments: StorageItemType[];\n  {{/unless}}\n  {{#each this.columns}}\n  {{this.name}}{{#unless this.required}}?{{/unless}}: {{typeName this}};\n  {{/each}}\n  {{#if this.enableForm}}\n  formSchema: FormValidationRules;\n  {{/if}}\n};\n\nexport type {{toCodeTypeName this.name}}CreateInput = {\n  {{#unless this.isSubmissions}}\n  group?: string;\n  publishedAt?: string;\n  scheduledPublishAt?: string | null;\n  scheduledUnpublishAt?: string | null;\n  createdAt?: string;\n  {{/unless}}\n  {{#each this.columns}}\n  {{this.name}}{{#unless this.required}}?{{/unless}}: {{typeName this}};\n  {{/each}}\n  {{#if this.enableForm}}\n  formSchema: FormValidationRules;\n  {{/if}}\n};\n\nexport type {{toCodeTypeName this.name}}UpdateInput = {\n  {{#each this.columns}}\n  {{#unless this.readOnly}}{{this.name}}?: {{typeName this}}{{#unless this.required}} | null{{/unless}};{{/unless}}\n  {{/each}}\n  {{#unless this.isSubmissions}}\n  publishedAt?: string;\n  scheduledPublishAt?: string | null;\n  scheduledUnpublishAt?: string | null;\n  createdAt?: string;\n  {{/unless}}\n  {{#if this.enableForm}}\n  formSchema: FormValidationRules;\n  {{/if}}\n};\n{{/each}}\n\n// Module types\n{{#each tableModules}}\nexport type {{toCodeTypeName this.name}} = {\n  id?: string;\n  {{#each this.columns}}\n  {{this.name}}{{#unless this.required}}?{{/unless}}: {{typeName this}};\n  {{/each}}\n};\n{{/each}}\n\n\n// Descriptor types\n{{#each tables}}\nexport type {{toCodeTypeName this.name}}__Descriptor = {\n  row: {{toCodeTypeName this.name}};\n  create: {{toCodeTypeName this.name}}CreateInput;\n  update: {{toCodeTypeName this.name}}UpdateInput;\n  {{#if (filterRefColumn this.columns)}}\n  refs: {\n    {{#each (filterRefColumn this.columns)}}\n    {{includeName this}}: {{{includeType this}}};\n    {{/each}}\n  }\n  {{/if}}\n  {{#unless (filterRefColumn this.columns)}}\n  refs: object;\n  {{/unless}}\n  {{#if (filterUniqueIndexes this.indexes)}}\n  unique: [\n    {{#each (filterUniqueIndexes this.indexes)}}\n      { {{#each (getIndexColumns ../this this)}}{{this.name}}:{{typeName this}},{{/each}} },\n    {{/each}}\n  ]\n  {{/if}}\n  {{#unless (filterUniqueIndexes this.indexes)}}\n  unique: [];\n  {{/unless}}\n  {{#if this.enableDrafts}}\n  enableDrafts: true;\n  {{/if}}\n  {{#if this.enableForm}}\n  submissionDescriptor: {{toCodeTypeName this.name}}_Submission__Descriptor;\n  {{else}}\n  submissionDescriptor: never;\n  {{/if}}\n};\n{{/each}}\n\n\n{{#each tableModules}}\nexport type {{toCodeTypeName this.name}}__Descriptor = {\n  row: {{toCodeTypeName this.name}};\n  {{#if (filterRefColumn this.columns)}}\n  refs: {\n    {{#each (filterRefColumn this.columns)}}\n    {{includeName this}}: {{{includeType this}}};\n    {{/each}}\n  }\n  {{/if}}\n  {{#unless (filterRefColumn this.columns)}}\n  refs: object;\n  {{/unless}}\n  unique:[]\n};\n{{/each}}\n\n\n// Webhook types\nexport type WebhookEvent = "content.create" | "content.update" | "content.delete";\nexport type WebhookPayload = {\n  event: WebhookEvent;\n  timestamp: string;\n  project: string;\n} & (\n  {{#each tables}}\n  | {\n      table: "{{this.name}}";\n      content: {{toCodeTypeName this.name}};\n      old?: {{toCodeTypeName this.name}};\n    }\n  {{/each}}\n)\n';
+
+// src/cms/templates/client.ts.hbr
+var client_ts_default = '//  This file was automatically generated and should not be edited.\n\nimport { OrizmCMSClient } from "@orizm/cms-sdk";\n\nimport * as Models from "./types";\n\nexport class CMSClient {\n  constructor(protected client: OrizmCMSClient) {\n    this.tables = {\n      {{#each tables}}\n      {{toEndpointName this.name}}: this.client.getTableClient<Models.{{toCodeTypeName this.name}}__Descriptor>("{{toEndpointName this.name}}"),\n      {{/each}}\n    };\n\n    this.buckets = {\n      {{#each buckets}}\n      {{toEndpointName this.name}}: this.client.getBucketClient("{{toEndpointName this.name}}"),\n      {{/each}}\n    };\n\n    this.userManagement = this.client.userManagement;\n  \n    this.userinfo = this.client.userinfo;\n  \n    this.auth = this.client.auth;\n  }\n\n  readonly tables;\n  readonly buckets;\n  readonly userManagement;\n  readonly userinfo;\n  readonly auth;\n}\n';
+
+// src/cms/generate/generator.ts
+import_handlebars.default.registerHelper("toEndpointName", (str) => {
+  return str;
+});
+function toCodeTypeName(str) {
+  str = str.charAt(0).toUpperCase() + str.slice(1);
+  return str.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
+}
+import_handlebars.default.registerHelper("toCodeTypeName", toCodeTypeName);
+import_handlebars.default.registerHelper(
+  "typeName",
+  (column) => {
+    if (column.type === "reference") {
+      return "string";
+    } else if (column.type === "module") {
+      return toCodeTypeName(column.moduleName);
+    } else if (column.type === "module-array") {
+      return toCodeTypeName(column.moduleName) + "[]";
+    } else if (column.type == "json") {
+      return "unknown";
+    } else if (column.type === "storage") {
+      return "StorageItemType";
+    } else {
+      return column.type;
+    }
+  }
+);
+import_handlebars.default.registerHelper(
+  "filterRefColumn",
+  (columns) => {
+    return (columns || []).filter(
+      (c) => c.type === "reference" && c.tableName && c.includeName || c.type === "module" && c.moduleName || c.type === "module-array" && c.moduleName
+    );
+  }
+);
+import_handlebars.default.registerHelper(
+  "includeName",
+  (column) => {
+    return column.type === "reference" ? column.includeName : column.name;
+  }
+);
+import_handlebars.default.registerHelper(
+  "includeType",
+  (column) => {
+    if (column.type === "reference")
+      return toCodeTypeName(column.tableName) + "__Descriptor";
+    if (column.type === "module")
+      return `_ModuleRef<${toCodeTypeName(column.moduleName)}__Descriptor>`;
+    if (column.type === "module-array")
+      return `_ArrayModuleRef<${toCodeTypeName(
+        column.moduleName
+      )}__Descriptor>`;
+  }
+);
+import_handlebars.default.registerHelper(
+  "filterUniqueIndexes",
+  (indexes) => {
+    return (indexes || []).filter((i) => i.unique);
+  }
+);
+import_handlebars.default.registerHelper(
+  "getIndexColumns",
+  (table, index) => {
+    return index.columns.map((i) => {
+      const column = table.columns.find((c) => c.name === i);
+      if (!column) {
+        throw new Error(`column ${i} not found`);
+      }
+      return column;
+    });
+  }
+);
+async function generate(options) {
+  const config = options.projectDef;
+  await (0, import_promises.mkdir)(options.output, { recursive: true });
+  await renderTypes(config, options.output);
+  await renderClient(config, options.output);
+}
+async function renderTypes(config, output) {
+  const submissionTables = config.tables.filter((t) => t.enableForm).map((t) => ({
+    name: t.name + "__submission",
+    columns: t.formOptions?.submissionColumns || [],
+    isSubmissions: true
+  }));
+  const renderParams = {
+    ...config,
+    tables: [...config.tables, ...submissionTables]
+  };
+  const rendered = import_handlebars.default.compile(types_ts_default)(renderParams);
+  const targetPath = import_path.default.join(output, "types.ts");
+  await (0, import_promises.writeFile)(targetPath, rendered, "utf-8");
+}
+async function renderClient(config, output) {
+  const rendered = import_handlebars.default.compile(client_ts_default)(config);
+  const targetPath = import_path.default.join(output, "client.ts");
+  await (0, import_promises.writeFile)(targetPath, rendered, "utf-8");
+}
+
+// src/cms/generate/command.ts
+var spinner = createSpinner();
+var cmsGenerateCommand = new import_commander.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) => {
+  try {
+    spinner.start("Loading project schema...");
+    const projectDef = await loadConfig(options.config);
+    spinner.succeed("Loaded project schema.");
+    spinner.start("Generating code...");
+    await generate({
+      projectDef,
+      output: options.output
+    });
+    spinner.succeed(`Generated code to '${options.output}'`);
+  } catch (error2) {
+    handleError(error2);
+  }
+});
+
+// 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"));
+function createDeveloperAPIClient(baseUrl, apiKey) {
+  const url = new URL(baseUrl);
+  url.pathname = `/api/dev/v1`;
+  return (0, import_openapi_fetch.default)({
+    baseUrl: url.toString(),
+    headers: {
+      "x-api-key": apiKey
+    }
+  });
+}
+
+// src/cms/pull/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 } }
+    }
+  );
+  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.`);
+  }
+  throw new Error(
+    `Unknown error occurred when fetching definitions for project ${options.projectName}.`
+  );
+}
+
+// src/cms/pull/load-env.ts
+var import_promises2 = __toESM(require("fs/promises"));
+var v3 = __toESM(require("valibot"));
+var import_dotenv = __toESM(require("dotenv"));
+var EnvSchema = v3.object({
+  ORIZM_PROJECT: v3.pipe(
+    v3.string(),
+    v3.minLength(1, "ORIZM_PROJECT is required"),
+    v3.brand("ORIZM_PROJECT")
+  ),
+  ORIZM_BASE_URL: v3.pipe(
+    v3.optional(v3.string(), "https://app.orizm.com"),
+    // if null, use default value
+    v3.transform((v4) => v4.replace(/\/$/, "")),
+    // remove trailing slash
+    v3.brand("ORIZM_BASE_URL")
+  ),
+  ORIZM_API_KEY: v3.pipe(
+    v3.string(),
+    v3.minLength(1, "ORIZM_API_KEY is required"),
+    v3.brand("ORIZM_API_KEY")
+  )
+});
+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) {
+    throw new Error(
+      `Environment variables are not valid. ${envParseResult.issues.map((issue) => `${issue.message}(at ${issue.path})`).join("\n")}`
+    );
+  }
+  const env = envParseResult.output;
+  return env;
+}
+
+// src/cms/pull/action.ts
+var spinner2 = createSpinner();
+async function pullAction(options) {
+  const env = await loadEnv(options.envPath);
+  spinner2.start("Loading project schema...");
+  const definitionReference = await fetchDefinitionReference({
+    baseUrl: env.ORIZM_BASE_URL,
+    apiKey: env.ORIZM_API_KEY,
+    projectName: env.ORIZM_PROJECT
+  });
+  spinner2.succeed("Loaded project schema.");
+  spinner2.start("Generating code...");
+  await generate({
+    output: options.destination,
+    projectDef: definitionReference
+  });
+  spinner2.succeed(`Generated code to '${options.destination}'`);
+}
+
+// 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) => {
+  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);
+  }
+});
+
+// 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';
+
+// src/consumer/templates/types.ts.hbr
+var types_ts_default2 = '//  This file was automatically generated and should not be edited.\n\nimport { FormValidationRules, StorageItemType } from "@orizm/common";\n\n// Utilities\ntype _ModuleRef<T> = T & _ModuleDescriptor;\ntype _ModuleDescriptor = {\n    isModule: true;\n};\ntype _ArrayModuleRef<T> = T & _ArrayModuleDescriptor;\ntype _ArrayModuleDescriptor = {\n    isModuleArray: true;\n};\n\n\n// Tables\n{{#each tables}}\nexport type {{toCodeTypeName this.name}} = {\n  id: string;\n  createdAt: string;\n  updatedAt: string;\n  group?: string;\n  publishedAt?: string;\n  _draft?: boolean;\n  _published?: boolean;\n  {{#each this.columns}}\n  {{this.name}}{{#unless this.required}}?{{/unless}}: {{typeName this}};\n  {{/each}}\n  {{#if this.enableForm}}\n  formSchema: FormValidationRules;\n  {{/if}}\n}\n\n{{/each}}\n\n{{#each tableModules}}\nexport type {{toCodeTypeName this.name}} = {\n  {{#each this.columns}}\n  {{this.name}}{{#unless this.required}}?{{/unless}}: {{typeName this}};\n  {{/each}}\n};\n{{/each}}\n\n// Descriptor types\n{{#each tables}}\nexport type {{toCodeTypeName this.name}}__Descriptor = {\n  row: {{toCodeTypeName this.name}};\n  {{#if (filterRefColumn this.columns)}}\n  refs: {\n    {{#each (filterRefColumn this.columns)}}\n    {{includeName this}}: {{{includeType this}}};\n    {{/each}}\n  }\n  {{/if}}\n  {{#unless (filterRefColumn this.columns)}}\n  refs: object;\n  {{/unless}}\n  {{#if (filterUniqueIndexes this.indexes)}}\n  unique: [\n    {{#each (filterUniqueIndexes this.indexes)}}\n      { {{#each (getIndexColumns ../this this)}}{{this.name}}:{{typeName this}},{{/each}} },\n    {{/each}}\n  ]\n  {{/if}}\n  {{#unless (filterUniqueIndexes this.indexes)}}\n  unique: [];\n  {{/unless}}\n  {{#if this.enableDrafts}}\n  enableDrafts: true;\n  {{/if}}\n};\n{{/each}}\n\n\n{{#each tableModules}}\nexport type {{toCodeTypeName this.name}}__Descriptor = {\n  row: {{toCodeTypeName this.name}};\n  {{#if (filterRefColumn this.columns)}}\n  refs: {\n    {{#each (filterRefColumn this.columns)}}\n    {{includeName this}}: {{{includeType this}}};\n    {{/each}}\n  }\n  {{/if}}\n  {{#unless (filterRefColumn this.columns)}}\n  refs: object;\n  {{/unless}}\n  unique:[]\n};\n{{/each}}\n\n\n// Webhook types\nexport type WebhookEvent = "content.create" | "content.update" | "content.delete";\nexport type WebhookPayload = {\n  event: WebhookEvent;\n  timestamp: string;\n  project: string;\n} & (\n  {{#each tables}}\n  | {\n      table: "{{this.name}}";\n      content: {{toCodeTypeName this.name}};\n      old?: {{toCodeTypeName this.name}};\n    }\n  {{/each}}\n)\n';
+
+// 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;
+});
+function toCodeTypeName2(str) {
+  str = str.charAt(0).toUpperCase() + str.slice(1);
+  return str.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
+}
+import_handlebars2.default.registerHelper("toCodeTypeName", toCodeTypeName2);
+import_handlebars2.default.registerHelper("typeName", (column) => {
+  if (column.type === "reference") {
+    return "string";
+  } else if (column.type == "json") {
+    return "unknown";
+  } else if (column.type === "module") {
+    if (!column.moduleName) {
+      console.warn("moduleName is not defined", column.name);
+    }
+    return toCodeTypeName2(column.moduleName || "unknown");
+  } else if (column.type === "module-array") {
+    if (!column.moduleName) {
+      console.warn("moduleName is not defined", column.name);
+    }
+    return toCodeTypeName2(column.moduleName || "unknown") + "[]";
+  } else if (column.type === "storage") {
+    return "StorageItemType";
+  } else {
+    return column.type;
+  }
+});
+import_handlebars2.default.registerHelper("filterRefColumn", (columns) => {
+  return (columns || []).filter(
+    (c) => c.type === "reference" && c.tableName && c.includeName || c.type === "module" && c.moduleName || c.type === "module-array" && c.moduleName
+  );
+});
+import_handlebars2.default.registerHelper("includeName", (column) => {
+  return column.type === "reference" ? column.includeName : column.name;
+});
+import_handlebars2.default.registerHelper("includeType", (column) => {
+  if (column.type === "reference" && column.tableName)
+    return toCodeTypeName2(column.tableName) + "__Descriptor";
+  if (column.type === "module" && column.moduleName)
+    return `_ModuleRef<${toCodeTypeName2(column.moduleName)}__Descriptor>`;
+  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(
+  "getIndexColumns",
+  (table, index) => {
+    return index.columns.map((i) => {
+      const column = table.columns.find((c) => c.name === i);
+      if (!column) {
+        throw new Error(`column ${i} not found`);
+      }
+      return column;
+    });
+  }
+);
+async function renderTypes2(config, output) {
+  const rendered = import_handlebars2.default.compile(types_ts_default2)(config);
+  const targetPath = import_path2.default.join(output, "types.ts");
+  await (0, import_promises3.writeFile)(targetPath, rendered, "utf-8");
+}
+async function renderClient2(config, output) {
+  const rendered = import_handlebars2.default.compile(client_ts_default2)(config);
+  const targetPath = import_path2.default.join(output, "client.ts");
+  await (0, import_promises3.writeFile)(targetPath, rendered, "utf-8");
+}
+
+// src/consumer/generate/action.ts
+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);
+  }
+}
+
+// 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);
+});
+
+// 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
+  };
+}
+
+// src/consumer/pull/action.ts
+async function pullAction2(options) {
+  try {
+    const config = await loadConfig2(options.envPath);
+    const definition = await pullDefinition(config);
+    await generate2({
+      definition,
+      output: options.destination
+    });
+  } catch (e) {
+    console.error(import_cli_color5.default.red(e));
+    process.exit(1);
+  }
+}
+
+// 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;
+  }
+};
+
+// 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`,
+    body: { apply: true, project: projectDef }
+  });
+  if (!response.ok) {
+    const status = 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.`
+    );
+  }
+}
+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)}`);
+    }
+    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.`
+    );
+  }
+  return await response.json();
+};
+
+// src/lib/display-change-events.ts
+var import_cli_color6 = require("cli-color");
+
+// src/lib/cli-table.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  green: "\x1B[32m",
+  red: "\x1B[31m"
+};
+var CliTable = class {
+  headers = [];
+  rows = [];
+  columnWidths = [];
+  rowColors = [];
+  // 各行の色を保持する配列
+  constructor(headers) {
+    this.headers = headers;
+    this.updateColumnWidths(headers);
+  }
+  // データ行を追加
+  addRow(row, options) {
+    if (row.length !== this.headers.length) {
+      throw new Error(
+        `The length of the row (${row.length}) does not match the length of the header (${this.headers.length})`
+      );
+    }
+    this.rows.push(row);
+    if (options?.color) {
+      this.rowColors.push(COLORS[options.color]);
+    } else {
+      this.rowColors.push(null);
+    }
+    this.updateColumnWidths(row);
+  }
+  // 列幅を更新
+  updateColumnWidths(row) {
+    for (let i = 0; i < row.length; i++) {
+      const cellLength = row[i].length;
+      if (!this.columnWidths[i] || cellLength > this.columnWidths[i]) {
+        this.columnWidths[i] = cellLength;
+      }
+    }
+  }
+  // 水平線を生成
+  createHorizontalLine(position) {
+    let line = "";
+    if (position === "top") line += "\u250C";
+    else if (position === "middle") line += "\u251C";
+    else if (position === "bottom") line += "\u2514";
+    for (let i = 0; i < this.columnWidths.length; i++) {
+      line += "\u2500".repeat(this.columnWidths[i] + 2);
+      if (i < this.columnWidths.length - 1) {
+        if (position === "top") line += "\u252C";
+        else if (position === "middle") line += "\u253C";
+        else if (position === "bottom") line += "\u2534";
+      } else {
+        if (position === "top") line += "\u2510";
+        else if (position === "middle") line += "\u2524";
+        else if (position === "bottom") line += "\u2518";
+      }
+    }
+    return line;
+  }
+  // 行を整形
+  formatRow(row, color) {
+    let formattedRow = "\u2502";
+    for (let i = 0; i < row.length; i++) {
+      const cell = row[i];
+      const padding = " ".repeat(this.columnWidths[i] - cell.length);
+      if (color) {
+        formattedRow += ` ${color}${cell}${COLORS.reset}${padding} \u2502`;
+      } else {
+        formattedRow += ` ${cell}${padding} \u2502`;
+      }
+    }
+    return formattedRow;
+  }
+  // テーブルを文字列として取得
+  toString() {
+    if (this.headers.length === 0) {
+      return "";
+    }
+    const topLine = this.createHorizontalLine("top");
+    const middleLine = this.createHorizontalLine("middle");
+    const bottomLine = this.createHorizontalLine("bottom");
+    let table = topLine + "\n";
+    table += this.formatRow(this.headers, null) + "\n";
+    table += middleLine + "\n";
+    for (let i = 0; i < this.rows.length; i++) {
+      const color = this.rowColors[i] || null;
+      table += this.formatRow(this.rows[i], color) + "\n";
+    }
+    table += bottomLine;
+    return table;
+  }
+  // テーブルを出力
+  print() {
+    console.log(this.toString());
+  }
+};
+
+// src/lib/display-change-events.ts
+async function displayChangeEvents(changeEvents) {
+  const tableChangeEvents = changeEvents.tableChangeEvents ?? [];
+  if (tableChangeEvents.length === 0) {
+    console.log();
+    console.log((0, import_cli_color6.green)("No changes."));
+    return;
+  }
+  const eventsByTable = /* @__PURE__ */ new Map();
+  for (const event of tableChangeEvents) {
+    const tableName = event.tableDef.name;
+    const tableEvents = eventsByTable.get(tableName) ?? [];
+    tableEvents.push(event);
+    eventsByTable.set(tableName, tableEvents);
+  }
+  for (const [tableName, events] of eventsByTable.entries()) {
+    console.log();
+    console.log(`\u26AB\uFE0ETable: ${tableName}`);
+    const table = new CliTable(["Type", "Name", "Event", "Detail"]);
+    for (const event of events) {
+      const eventName = event.event;
+      switch (eventName) {
+        case "table:create":
+        case "table:update": {
+          table.addRow(["table", event.tableDef.name, eventName, ""], {
+            color: "green"
+          });
+          break;
+        }
+        case "table:delete": {
+          table.addRow(["table", event.tableDef.name, eventName, ""], {
+            color: "red"
+          });
+          break;
+        }
+        case "column:create":
+        case "column:update": {
+          table.addRow(
+            [
+              "column",
+              event.columnDef.name,
+              eventName,
+              JSON.stringify(event.columnDef)
+            ],
+            { color: "green" }
+          );
+          break;
+        }
+        case "column:delete": {
+          table.addRow(
+            [
+              "column",
+              event.columnDef.name,
+              eventName,
+              JSON.stringify(event.columnDef)
+            ],
+            {
+              color: "red"
+            }
+          );
+          break;
+        }
+        case "index:create":
+        case "index:update": {
+          table.addRow(
+            [
+              "index",
+              event.indexDef.columns.join(", "),
+              eventName,
+              JSON.stringify(event.indexDef)
+            ],
+            { color: "green" }
+          );
+          break;
+        }
+        case "index:delete": {
+          table.addRow(
+            [
+              "index",
+              event.indexDef.columns.join(", "),
+              eventName,
+              JSON.stringify(event.indexDef)
+            ],
+            { color: "red" }
+          );
+          break;
+        }
+        case "module:create":
+        case "module:update": {
+          table.addRow(
+            [
+              "module",
+              event.columnDef.name,
+              eventName,
+              JSON.stringify(event.columnDef)
+            ],
+            {
+              color: "green"
+            }
+          );
+          break;
+        }
+        case "module:delete": {
+          table.addRow(
+            [
+              "module",
+              event.columnDef.name,
+              eventName,
+              JSON.stringify(event.columnDef)
+            ],
+            {
+              color: "red"
+            }
+          );
+          break;
+        }
+        case "search:enable":
+        case "search:update": {
+          table.addRow(["table", event.tableDef.name, eventName, ""], {
+            color: "green"
+          });
+          break;
+        }
+        case "search:disable": {
+          table.addRow(["table", event.tableDef.name, eventName, ""], {
+            color: "red"
+          });
+          break;
+        }
+        case "history:enable": {
+          table.addRow(["table", event.tableDef.name, eventName, ""], {
+            color: "green"
+          });
+          break;
+        }
+        case "history:disable": {
+          table.addRow(["table", event.tableDef.name, eventName, ""], {
+            color: "red"
+          });
+          break;
+        }
+        case "formSubmissions:create":
+        case "formSubmissions:update": {
+          table.addRow(["table", event.tableDef.name, eventName, ""], {
+            color: "green"
+          });
+          break;
+        }
+        case "formSubmissions:delete": {
+          table.addRow(["table", event.tableDef.name, eventName, ""], {
+            color: "red"
+          });
+          break;
+        }
+      }
+    }
+    table.print();
+    console.log();
+  }
+}
+
+// src/lib/cli-input.ts
+var import_promises4 = require("readline/promises");
+async function input(prompt) {
+  const rl = (0, import_promises4.createInterface)({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const input2 = await rl.question(prompt).finally(() => {
+    rl.close();
+  });
+  return input2.trim();
+}
+
+// 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) => {
+  try {
+    spinner3.start("Loading environment variables...");
+    const env = new EnvManager(options.env);
+    spinner3.succeed("Loaded environment variables.");
+    spinner3.start("Loading project schema...");
+    const projectDef = await loadConfig(options.config);
+    spinner3.succeed("Loaded project schema.");
+    spinner3.start("Fetch schema change events...");
+    const changeEvents = await getChangeEvents(env, projectDef);
+    spinner3.succeed("Fetch schema change events.");
+    await displayChangeEvents(changeEvents);
+    if (changeEvents.tableChangeEvents.length === 0) {
+      return;
+    }
+    if (options.dryRun) {
+      return;
+    }
+    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."));
+        return;
+      }
+    }
+    spinner3.start("Applying schema...");
+    await applyDefinition(env, projectDef);
+    spinner3.succeed("Schema applied.");
+  } catch (error2) {
+    handleError(error2);
+  }
+});
+
+// src/cli.ts
+import_commander6.program.name("orizm CLI");
+import_commander6.program.addCommand(pushCommand);
+var cmsCommands = new import_commander6.Command("cms").description("cms commands.");
+cmsCommands.addCommand(cmsGenerateCommand);
+cmsCommands.addCommand(cmsPullCommand);
+import_commander6.program.addCommand(cmsCommands);
+var consumerCommands = new import_commander6.Command("consumer").description(
+  "consumer commands."
+);
+consumerCommands.addCommand(consumerGenerateCommand);
+consumerCommands.addCommand(consumerPullCommand);
+import_commander6.program.addCommand(consumerCommands);
+import_commander6.program.parse();

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@orizm/cli",
+  "version": "0.1.0",
+  "description": "Orizm CLI",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/chot-Inc/superx.git",
+    "directory": "packages/orizm-cli"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "cli-color": "^2.0.3",
+    "commander": "^10.0.0",
+    "dotenv": "^16.3.1",
+    "esbuild": "^0.17.19",
+    "handlebars": "^4.7.7",
+    "openapi-fetch": "^0.12.2",
+    "valibot": "^1.0.0",
+    "@orizm/common": "1.11.0"
+  },
+  "bin": {
+    "orizm": "bin/index.js"
+  },
+  "devDependencies": {
+    "@types/cli-color": "^2.0.2",
+    "openapi-typescript": "^7.6.1",
+    "@orizm/package-configs": "0.0.0"
+  },
+  "license": "Apache-2.0",
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "generate": "openapi-typescript ../../apps/server/openapi/developerAPI.yaml --output src/api/developer-api.d.ts"
+  }
+}