@orizm/cli 1.0.2 → 1.1.0

package/dist/cli.cjs

@@ -0,0 +1,1726 @@
+"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 __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_commander8 = require("commander");
+
+// src/cms/generate/command.ts
+var import_commander = require("commander");
+
+// src/lib/load-config.ts
+var import_esbuild = __toESM(require("esbuild"), 1);
+var import_config_validator = require("@orizm/common/config-validator");
+var v = __toESM(require("valibot"), 1);
+async function loadConfig(configFile) {
+  const buildResult = await import_esbuild.default.build({
+    entryPoints: [configFile],
+    bundle: true,
+    write: false,
+    format: "esm",
+    target: "node16",
+    platform: "node"
+  });
+  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
+var import_readline = __toESM(require("readline"), 1);
+
+// src/lib/cli-symbol.ts
+var import_cli_color = __toESM(require("cli-color"), 1);
+var success = import_cli_color.default.green("\u2713");
+var error = import_cli_color.default.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 v3 = __toESM(require("valibot"), 1);
+var import_cli_color3 = __toESM(require("cli-color"), 1);
+
+// src/lib/display-valibot-error.ts
+var v2 = __toESM(require("valibot"), 1);
+var import_cli_color2 = __toESM(require("cli-color"), 1);
+function displayValibotError(error2) {
+  if (!v2.isValiError(error2)) {
+    return;
+  }
+  console.error(`Error: ${error2.issues.length} problem(s) found.`);
+  console.error(buildValiErrorMessage(error2));
+}
+function buildValiErrorMessage(e, options) {
+  const { color = true } = options ?? {};
+  return e.issues.map((issue) => {
+    const path3 = getPath(issue);
+    return `  ${getIssueMessage(issue.message, color)} (at ${getLocationPath(path3, color)})`;
+  }).join("\n");
+}
+function getIssueMessage(message, color) {
+  return color ? import_cli_color2.default.red(message) : message;
+}
+function getLocationPath(path3, color) {
+  return color ? import_cli_color2.default.yellow(path3) : path3;
+}
+function getPath(issue) {
+  const issueDotPath = v2.getDotPath(issue);
+  const pathInfo = issue.path;
+  if (!issueDotPath || !pathInfo) {
+    return "";
+  }
+  const pathParts = issueDotPath.split(".");
+  let pathInfoIndex = 0;
+  for (let i = 0; i < pathParts.length; i++) {
+    const part = pathParts[i];
+    if (!isNumberIndex(part)) {
+      continue;
+    }
+    const index = parseInt(part);
+    for (let j = pathInfoIndex; j < pathInfo.length; j++) {
+      const pathItem = pathInfo[j];
+      if (pathItem.type === "array" && pathItem.key === index) {
+        if (pathItem.value && typeof pathItem.value === "object" && "name" in pathItem.value) {
+          pathParts[i] = String(pathItem.value.name);
+          pathInfoIndex = j + 1;
+          break;
+        }
+      }
+    }
+  }
+  return pathParts.join(".");
+}
+function isNumberIndex(part) {
+  return /^\d+$/.test(part);
+}
+
+// src/lib/handle-error.ts
+function handleError(error2) {
+  show();
+  if (v3.isValiError(error2)) {
+    console.error();
+    displayValibotError(error2);
+    console.error();
+    process.exit(1);
+  }
+  console.error();
+  console.error(
+    import_cli_color3.default.red(
+      "Something went wrong. Please check the error below for more details."
+    )
+  );
+  console.error();
+  console.error(error2);
+  console.error();
+  process.exit(1);
+}
+
+// src/cms/generate/generator.ts
+var import_promises = require("fs/promises");
+var import_path = __toESM(require("path"), 1);
+var import_handlebars = __toESM(require("handlebars"), 1);
+
+// 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";\ntype WebhookPayloadBase = {\n  event: WebhookEvent;\n  timestamp: string;\n  project: string;\n};\n{{#if tables}}\nexport type WebhookPayload = WebhookPayloadBase & (\n  {{#each tables}}\n  | {\n      table: "{{this.name}}";\n      content: {{toCodeTypeName this.name}};\n      old?: {{toCodeTypeName this.name}};\n    }\n  {{/each}}\n);\n{{else}}\nexport type WebhookPayload = WebhookPayloadBase;\n{{/if}}\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.config;
+  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 config = await loadConfig(options.config);
+    spinner.succeed("Loaded project schema.");
+    spinner.start("Generating code...");
+    await generate({
+      config,
+      output: options.output
+    });
+    spinner.succeed(`Generated code to '${options.output}'`);
+  } catch (error2) {
+    handleError(error2);
+  }
+});
+
+// src/cms/pull/command.ts
+var import_commander2 = require("commander");
+
+// ../../node_modules/.pnpm/openapi-fetch@0.13.5/node_modules/openapi-fetch/dist/index.js
+var PATH_PARAM_RE = /\{[^{}]+\}/g;
+var supportsRequestInitExt = () => {
+  return typeof process === "object" && Number.parseInt(process?.versions?.node?.substring(0, 2)) >= 18 && process.versions.undici;
+};
+function randomID() {
+  return Math.random().toString(36).slice(2, 11);
+}
+function createClient(clientOptions) {
+  let {
+    baseUrl = "",
+    Request: CustomRequest = globalThis.Request,
+    fetch: baseFetch = globalThis.fetch,
+    querySerializer: globalQuerySerializer,
+    bodySerializer: globalBodySerializer,
+    headers: baseHeaders,
+    requestInitExt = void 0,
+    ...baseOptions
+  } = { ...clientOptions };
+  requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+  baseUrl = removeTrailingSlash(baseUrl);
+  const middlewares = [];
+  async function coreFetch(schemaPath, fetchOptions) {
+    const {
+      baseUrl: localBaseUrl,
+      fetch = baseFetch,
+      Request = CustomRequest,
+      headers,
+      params = {},
+      parseAs = "json",
+      querySerializer: requestQuerySerializer,
+      bodySerializer = globalBodySerializer ?? defaultBodySerializer,
+      body,
+      ...init
+    } = fetchOptions || {};
+    if (localBaseUrl) {
+      baseUrl = removeTrailingSlash(localBaseUrl);
+    }
+    let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+    if (requestQuerySerializer) {
+      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+        ...requestQuerySerializer
+      });
+    }
+    const serializedBody = body === void 0 ? void 0 : bodySerializer(body);
+    const defaultHeaders = (
+      // with no body, we should not to set Content-Type
+      serializedBody === void 0 || // if serialized body is FormData; browser will correctly set Content-Type & boundary expression
+      serializedBody instanceof FormData ? {} : {
+        "Content-Type": "application/json"
+      }
+    );
+    const requestInit = {
+      redirect: "follow",
+      ...baseOptions,
+      ...init,
+      body: serializedBody,
+      headers: mergeHeaders(defaultHeaders, baseHeaders, headers, params.header)
+    };
+    let id;
+    let options;
+    let request = new CustomRequest(createFinalURL(schemaPath, { baseUrl, params, querySerializer }), requestInit);
+    let response;
+    for (const key in init) {
+      if (!(key in request)) {
+        request[key] = init[key];
+      }
+    }
+    if (middlewares.length) {
+      id = randomID();
+      options = Object.freeze({
+        baseUrl,
+        fetch,
+        parseAs,
+        querySerializer,
+        bodySerializer
+      });
+      for (const m of middlewares) {
+        if (m && typeof m === "object" && typeof m.onRequest === "function") {
+          const result = await m.onRequest({
+            request,
+            schemaPath,
+            params,
+            options,
+            id
+          });
+          if (result) {
+            if (result instanceof CustomRequest) {
+              request = result;
+            } else if (result instanceof Response) {
+              response = result;
+              break;
+            } else {
+              throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+            }
+          }
+        }
+      }
+    }
+    if (!response) {
+      try {
+        response = await fetch(request, requestInitExt);
+      } catch (error3) {
+        let errorAfterMiddleware = error3;
+        if (middlewares.length) {
+          for (let i = middlewares.length - 1; i >= 0; i--) {
+            const m = middlewares[i];
+            if (m && typeof m === "object" && typeof m.onError === "function") {
+              const result = await m.onError({
+                request,
+                error: errorAfterMiddleware,
+                schemaPath,
+                params,
+                options,
+                id
+              });
+              if (result) {
+                if (result instanceof Response) {
+                  errorAfterMiddleware = void 0;
+                  response = result;
+                  break;
+                }
+                if (result instanceof Error) {
+                  errorAfterMiddleware = result;
+                  continue;
+                }
+                throw new Error("onError: must return new Response() or instance of Error");
+              }
+            }
+          }
+        }
+        if (errorAfterMiddleware) {
+          throw errorAfterMiddleware;
+        }
+      }
+      if (middlewares.length) {
+        for (let i = middlewares.length - 1; i >= 0; i--) {
+          const m = middlewares[i];
+          if (m && typeof m === "object" && typeof m.onResponse === "function") {
+            const result = await m.onResponse({
+              request,
+              response,
+              schemaPath,
+              params,
+              options,
+              id
+            });
+            if (result) {
+              if (!(result instanceof Response)) {
+                throw new Error("onResponse: must return new Response() when modifying the response");
+              }
+              response = result;
+            }
+          }
+        }
+      }
+    }
+    if (response.status === 204 || response.headers.get("Content-Length") === "0") {
+      return response.ok ? { data: void 0, response } : { error: void 0, response };
+    }
+    if (response.ok) {
+      if (parseAs === "stream") {
+        return { data: response.body, response };
+      }
+      return { data: await response[parseAs](), response };
+    }
+    let error2 = await response.text();
+    try {
+      error2 = JSON.parse(error2);
+    } catch {
+    }
+    return { error: error2, response };
+  }
+  return {
+    request(method, url, init) {
+      return coreFetch(url, { ...init, method: method.toUpperCase() });
+    },
+    /** Call a GET endpoint */
+    GET(url, init) {
+      return coreFetch(url, { ...init, method: "GET" });
+    },
+    /** Call a PUT endpoint */
+    PUT(url, init) {
+      return coreFetch(url, { ...init, method: "PUT" });
+    },
+    /** Call a POST endpoint */
+    POST(url, init) {
+      return coreFetch(url, { ...init, method: "POST" });
+    },
+    /** Call a DELETE endpoint */
+    DELETE(url, init) {
+      return coreFetch(url, { ...init, method: "DELETE" });
+    },
+    /** Call a OPTIONS endpoint */
+    OPTIONS(url, init) {
+      return coreFetch(url, { ...init, method: "OPTIONS" });
+    },
+    /** Call a HEAD endpoint */
+    HEAD(url, init) {
+      return coreFetch(url, { ...init, method: "HEAD" });
+    },
+    /** Call a PATCH endpoint */
+    PATCH(url, init) {
+      return coreFetch(url, { ...init, method: "PATCH" });
+    },
+    /** Call a TRACE endpoint */
+    TRACE(url, init) {
+      return coreFetch(url, { ...init, method: "TRACE" });
+    },
+    /** Register middleware */
+    use(...middleware) {
+      for (const m of middleware) {
+        if (!m) {
+          continue;
+        }
+        if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
+          throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
+        }
+        middlewares.push(m);
+      }
+    },
+    /** Unregister middleware */
+    eject(...middleware) {
+      for (const m of middleware) {
+        const i = middlewares.indexOf(m);
+        if (i !== -1) {
+          middlewares.splice(i, 1);
+        }
+      }
+    }
+  };
+}
+function serializePrimitiveParam(name, value, options) {
+  if (value === void 0 || value === null) {
+    return "";
+  }
+  if (typeof value === "object") {
+    throw new Error(
+      "Deeply-nested arrays/objects aren\u2019t supported. Provide your own `querySerializer()` to handle these."
+    );
+  }
+  return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+function serializeObjectParam(name, value, options) {
+  if (!value || typeof value !== "object") {
+    return "";
+  }
+  const values = [];
+  const joiner = {
+    simple: ",",
+    label: ".",
+    matrix: ";"
+  }[options.style] || "&";
+  if (options.style !== "deepObject" && options.explode === false) {
+    for (const k in value) {
+      values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(value[k]));
+    }
+    const final2 = values.join(",");
+    switch (options.style) {
+      case "form": {
+        return `${name}=${final2}`;
+      }
+      case "label": {
+        return `.${final2}`;
+      }
+      case "matrix": {
+        return `;${name}=${final2}`;
+      }
+      default: {
+        return final2;
+      }
+    }
+  }
+  for (const k in value) {
+    const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+    values.push(serializePrimitiveParam(finalName, value[k], options));
+  }
+  const final = values.join(joiner);
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+function serializeArrayParam(name, value, options) {
+  if (!Array.isArray(value)) {
+    return "";
+  }
+  if (options.explode === false) {
+    const joiner2 = { form: ",", spaceDelimited: "%20", pipeDelimited: "|" }[options.style] || ",";
+    const final = (options.allowReserved === true ? value : value.map((v6) => encodeURIComponent(v6))).join(joiner2);
+    switch (options.style) {
+      case "simple": {
+        return final;
+      }
+      case "label": {
+        return `.${final}`;
+      }
+      case "matrix": {
+        return `;${name}=${final}`;
+      }
+      // case "spaceDelimited":
+      // case "pipeDelimited":
+      default: {
+        return `${name}=${final}`;
+      }
+    }
+  }
+  const joiner = { simple: ",", label: ".", matrix: ";" }[options.style] || "&";
+  const values = [];
+  for (const v6 of value) {
+    if (options.style === "simple" || options.style === "label") {
+      values.push(options.allowReserved === true ? v6 : encodeURIComponent(v6));
+    } else {
+      values.push(serializePrimitiveParam(name, v6, options));
+    }
+  }
+  return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
+}
+function createQuerySerializer(options) {
+  return function querySerializer(queryParams) {
+    const search = [];
+    if (queryParams && typeof queryParams === "object") {
+      for (const name in queryParams) {
+        const value = queryParams[name];
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
+            continue;
+          }
+          search.push(
+            serializeArrayParam(name, value, {
+              style: "form",
+              explode: true,
+              ...options?.array,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        if (typeof value === "object") {
+          search.push(
+            serializeObjectParam(name, value, {
+              style: "deepObject",
+              explode: true,
+              ...options?.object,
+              allowReserved: options?.allowReserved || false
+            })
+          );
+          continue;
+        }
+        search.push(serializePrimitiveParam(name, value, options));
+      }
+    }
+    return search.join("&");
+  };
+}
+function defaultPathSerializer(pathname, pathParams) {
+  let nextURL = pathname;
+  for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+    let name = match.substring(1, match.length - 1);
+    let explode = false;
+    let style = "simple";
+    if (name.endsWith("*")) {
+      explode = true;
+      name = name.substring(0, name.length - 1);
+    }
+    if (name.startsWith(".")) {
+      style = "label";
+      name = name.substring(1);
+    } else if (name.startsWith(";")) {
+      style = "matrix";
+      name = name.substring(1);
+    }
+    if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) {
+      continue;
+    }
+    const value = pathParams[name];
+    if (Array.isArray(value)) {
+      nextURL = nextURL.replace(match, serializeArrayParam(name, value, { style, explode }));
+      continue;
+    }
+    if (typeof value === "object") {
+      nextURL = nextURL.replace(match, serializeObjectParam(name, value, { style, explode }));
+      continue;
+    }
+    if (style === "matrix") {
+      nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+      continue;
+    }
+    nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+  }
+  return nextURL;
+}
+function defaultBodySerializer(body) {
+  if (body instanceof FormData) {
+    return body;
+  }
+  return JSON.stringify(body);
+}
+function createFinalURL(pathname, options) {
+  let finalURL = `${options.baseUrl}${pathname}`;
+  if (options.params?.path) {
+    finalURL = defaultPathSerializer(finalURL, options.params.path);
+  }
+  let search = options.querySerializer(options.params.query ?? {});
+  if (search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  if (search) {
+    finalURL += `?${search}`;
+  }
+  return finalURL;
+}
+function mergeHeaders(...allHeaders) {
+  const finalHeaders = new Headers();
+  for (const h of allHeaders) {
+    if (!h || typeof h !== "object") {
+      continue;
+    }
+    const iterator = h instanceof Headers ? h.entries() : Object.entries(h);
+    for (const [k, v6] of iterator) {
+      if (v6 === null) {
+        finalHeaders.delete(k);
+      } else if (Array.isArray(v6)) {
+        for (const v22 of v6) {
+          finalHeaders.append(k, v22);
+        }
+      } else if (v6 !== void 0) {
+        finalHeaders.set(k, v6);
+      }
+    }
+  }
+  return finalHeaders;
+}
+function removeTrailingSlash(url) {
+  if (url.endsWith("/")) {
+    return url.substring(0, url.length - 1);
+  }
+  return url;
+}
+
+// ../private-api-clients/src/assert-valid-url-origin.ts
+function assertValidUrlOrigin(origin) {
+  const url = new URL(origin);
+  if (url.origin !== origin) {
+    throw new Error(`${origin} is not a valid URL origin`);
+  }
+}
+
+// ../private-api-clients/src/dev-v2-api-client.ts
+function createDeveloperAPIv2Client({
+  serverOrigin = "",
+  fetch,
+  headers
+}) {
+  if (serverOrigin) assertValidUrlOrigin(serverOrigin);
+  return createClient({
+    baseUrl: `${serverOrigin}/api/dev/v2`,
+    fetch,
+    headers
+  });
+}
+
+// src/lib/fetch-current-definition.ts
+async function fetchCurrentDefinition(options) {
+  const client = createDeveloperAPIv2Client({
+    serverOrigin: options.baseUrl,
+    headers: {
+      "x-api-key": options.apiKey
+    }
+  });
+  const abortController = new AbortController();
+  const timeout = setTimeout(() => {
+    abortController.abort();
+  }, 1e4);
+  try {
+    const response = await client.GET(
+      "/projects/{projectName}/definitions/current",
+      {
+        params: { path: { projectName: options.projectName } },
+        signal: abortController.signal
+      }
+    );
+    if (response.data) {
+      return response.data;
+    }
+    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);
+  }
+}
+
+// src/lib/load-env.ts
+var import_promises2 = __toESM(require("fs/promises"), 1);
+var v4 = __toESM(require("valibot"), 1);
+var import_dotenv = __toESM(require("dotenv"), 1);
+var DEFAULT_ENV_FILE_PATH = ".env";
+var EnvSchema = v4.object({
+  ORIZM_PROJECT: v4.pipe(
+    v4.string(),
+    v4.minLength(1, "ORIZM_PROJECT is required"),
+    v4.brand("ORIZM_PROJECT")
+  ),
+  ORIZM_BASE_URL: v4.pipe(
+    v4.optional(v4.string(), "https://app.orizm.com"),
+    // if null, use default value
+    v4.transform((v6) => v6.replace(/\/$/, "")),
+    // remove trailing slash
+    v4.brand("ORIZM_BASE_URL")
+  ),
+  ORIZM_API_KEY: v4.pipe(
+    v4.string(),
+    v4.minLength(1, "ORIZM_API_KEY is required"),
+    v4.brand("ORIZM_API_KEY")
+  )
+});
+async function loadEnv(envPath) {
+  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 = v4.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 = v4.safeParse(EnvSchema, process.env);
+  if (!processEnvParseResult.success) {
+    throw new Error(
+      "Environment variables are not valid. Put .env file or set environment variables in process.env.\n" + processEnvParseResult.issues.map((issue) => issue.message).join("\n")
+    );
+  }
+  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 config...");
+  const definitionReference = await fetchCurrentDefinition({
+    baseUrl: env.ORIZM_BASE_URL,
+    apiKey: env.ORIZM_API_KEY,
+    projectName: env.ORIZM_PROJECT
+  });
+  spinner2.succeed("Loaded project config.");
+  spinner2.start("Generating code...");
+  await generate({
+    output: options.destination,
+    config: definitionReference.parsed
+  });
+  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.").option("-o, --output <path>", "output directory.", "./src/orizm").action(async (options) => {
+  try {
+    await pullAction({
+      destination: options.output,
+      envPath: options.env
+    });
+  } catch (error2) {
+    handleError(error2);
+  }
+});
+
+// src/consumer/generate/command.ts
+var import_commander3 = require("commander");
+
+// src/consumer/pull/generate.ts
+var import_promises3 = require("fs/promises");
+var import_path2 = __toESM(require("path"), 1);
+var import_handlebars2 = __toESM(require("handlebars"), 1);
+
+// 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";\ntype WebhookPayloadBase = {\n  event: WebhookEvent;\n  timestamp: string;\n  project: string;\n};\n{{#if tables}}\nexport type WebhookPayload = WebhookPayloadBase & (\n  {{#each tables}}\n  | {\n      table: "{{this.name}}";\n      content: {{toCodeTypeName this.name}};\n      old?: {{toCodeTypeName this.name}};\n    }\n  {{/each}}\n);\n{{else}}\nexport type WebhookPayload = WebhookPayloadBase;\n{{/if}}\n';
+
+// src/consumer/pull/generate.ts
+async function generate2(options) {
+  await (0, import_promises3.mkdir)(options.output, { recursive: true });
+  await renderTypes2(options.definition, options.output);
+  await renderClient2(options.definition, options.output);
+}
+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
+var spinner3 = createSpinner();
+async function generateAction(orizmConfigTs, destination) {
+  spinner3.start("Loading project config...");
+  const definition = await loadConfig(orizmConfigTs);
+  spinner3.succeed("Loaded project config.");
+  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) => {
+  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 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 config...");
+  const definition = await fetchCurrentDefinition({
+    baseUrl: config.ORIZM_BASE_URL,
+    apiKey: config.ORIZM_API_KEY,
+    projectName: config.ORIZM_PROJECT
+  });
+  spinner4.succeed("Loaded project config.");
+  spinner4.start("Generating code...");
+  await generate2({
+    definition: definition.parsed,
+    output: options.destination
+  });
+  spinner4.succeed(`Generated code to '${options.destination}'`);
+}
+
+// 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 {
+    await pullAction2({
+      destination: options.output,
+      envPath: options.env
+    });
+  } catch (error2) {
+    handleError(error2);
+  }
+});
+
+// src/push/command.ts
+var import_commander5 = require("commander");
+var import_cli_color5 = __toESM(require("cli-color"), 1);
+
+// src/lib/developer-api.ts
+async function applyDefinition(env, projectDef) {
+  const client = createDeveloperAPIv2Client({
+    serverOrigin: env.ORIZM_BASE_URL,
+    headers: {
+      "x-api-key": env.ORIZM_API_KEY
+    }
+  });
+  const response = await client.POST("/projects/{projectName}/definitions", {
+    params: { path: { projectName: env.ORIZM_PROJECT } },
+    body: { definition: 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."
+      );
+    }
+    throw new Error(
+      `${status} ${response.response.statusText}: Unexpected error occurred while applying schema.`
+    );
+  }
+}
+var getChangeEvents = async (env, projectDef) => {
+  const client = createDeveloperAPIv2Client({
+    serverOrigin: env.ORIZM_BASE_URL,
+    headers: {
+      "x-api-key": env.ORIZM_API_KEY
+    }
+  });
+  const response = await client.POST(
+    "/projects/{projectName}/definitions/dry-run",
+    {
+      params: { path: { projectName: env.ORIZM_PROJECT } },
+      body: { definition: 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."
+      );
+    }
+    throw new Error(
+      `${status} ${response.response.statusText}: Unexpected error occurred while fetching schema change events.
+      ${JSON.stringify(response.error, null, 2)}`
+    );
+  }
+  return response.data;
+};
+
+// src/lib/display-change-events.ts
+var import_cli_color4 = __toESM(require("cli-color"), 1);
+
+// 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 = [],
+    bucketChangeEvents = [],
+    authorityChangeEvents = []
+  } = changeEvents;
+  if (tableChangeEvents.length === 0 && bucketChangeEvents.length === 0 && authorityChangeEvents.length === 0) {
+    console.log();
+    console.log(import_cli_color4.default.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();
+  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();
+  }
+}
+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");
+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 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 {
+    spinner5.start("Loading environment variables...");
+    const env = await loadEnv(options.env);
+    spinner5.succeed("Loaded environment variables.");
+    spinner5.start("Loading project config...");
+    const projectDef = await loadConfig(options.config);
+    spinner5.succeed("Loaded project config.");
+    spinner5.start("Fetch schema change events...");
+    const changeEvents = await getChangeEvents(env, projectDef);
+    spinner5.succeed("Fetch schema change events.");
+    await displayChangeEvents(changeEvents);
+    if (changeEvents.tableChangeEvents.length === 0 && changeEvents.bucketChangeEvents.length === 0 && changeEvents.authorityChangeEvents.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(import_cli_color5.default.red("Canceled."));
+        return;
+      }
+    }
+    spinner5.start("Applying schema...");
+    await applyDefinition(env, projectDef);
+    spinner5.succeed("Schema applied.");
+  } catch (error2) {
+    handleError(error2);
+  }
+});
+
+// src/config/validate/command.ts
+var import_commander6 = require("commander");
+var import_cli_color6 = __toESM(require("cli-color"), 1);
+var v5 = __toESM(require("valibot"), 1);
+
+// src/config/validate/watcher.ts
+var import_chokidar = __toESM(require("chokidar"), 1);
+function watchConfigFile(configPath, onFileChange) {
+  const watcher = import_chokidar.default.watch(configPath, {
+    persistent: true,
+    ignoreInitial: true
+  });
+  let isProcessing = false;
+  let timeoutId = null;
+  const debouncedOnChange = async () => {
+    if (isProcessing) return;
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    timeoutId = setTimeout(async () => {
+      isProcessing = true;
+      try {
+        await onFileChange();
+      } catch (error2) {
+        handleError(error2);
+      } finally {
+        isProcessing = false;
+      }
+    }, 300);
+  };
+  watcher.on("change", debouncedOnChange);
+  watcher.on("add", debouncedOnChange);
+  watcher.on("unlink", debouncedOnChange);
+  const terminate = () => {
+    watcher.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", terminate);
+  process.on("SIGTERM", terminate);
+  watcher.on("error", (error2) => {
+    handleError(error2);
+  });
+  return watcher;
+}
+
+// src/config/validate/command.ts
+var validateConfigCommand = new import_commander6.Command("validate").description("validate orizm.config.ts for validation errors").option("-c, --config <path>", "Path to config file", "./orizm.config.ts").option("-w, --watch", "Watch for file changes and re-validate").action(async (options) => {
+  try {
+    const validateConfig = async () => {
+      try {
+        if (options.watch) {
+          console.clear();
+          console.log(
+            `\u{1F440} Watching ${options.config} for changes... (Press Ctrl+C to stop)`
+          );
+          console.log();
+        }
+        await loadConfig(options.config);
+        console.log(import_cli_color6.default.green("\u2705 Config is valid."));
+      } catch (error2) {
+        if (v5.isValiError(error2)) {
+          console.error(import_cli_color6.default.red("\u274C Config validation failed:"));
+          displayValibotError(error2);
+          return;
+        }
+        throw error2;
+      }
+    };
+    await validateConfig();
+    if (options.watch) {
+      watchConfigFile(options.config, validateConfig);
+    }
+  } catch (error2) {
+    handleError(error2);
+  }
+});
+
+// src/config/generate-erd/command.ts
+var import_commander7 = require("commander");
+
+// src/config/generate-erd/generate.ts
+var import_handlebars3 = __toESM(require("handlebars"), 1);
+
+// src/config/generate-erd/mermaid-erd.hbr
+var mermaid_erd_default = "generated by @orizm/cli\n\n```mermaid\nerDiagram\n{{#each tables}}\n    {{name}} {\n        id string PK\n{{#each columns}}\n        {{name}} {{type}}{{#if isForeignKey}} FK{{/if}}\n{{/each}}\n    }\n{{/each}}\n\n{{#each relations}}\n    {{from}} {{type}} {{to}} : {{comment}}\n{{/each}}\n```";
+
+// src/config/generate-erd/generate.ts
+function generate3(input2) {
+  const template = import_handlebars3.default.compile(mermaid_erd_default);
+  return template(input2);
+}
+
+// src/config/generate-erd/convert-to-input.ts
+function convertToInput(config) {
+  if (!config.tables) {
+    return {
+      tables: [],
+      relations: []
+    };
+  }
+  const tables = [];
+  const relations = [];
+  for (const table of config.tables) {
+    const modules = [];
+    const erdTable = {
+      name: table.name,
+      columns: []
+    };
+    for (const column of table.columns) {
+      erdTable.columns.push({
+        name: column.name,
+        type: column.type,
+        isForeignKey: column.type === "reference"
+      });
+      if (column.type === "reference") {
+        relations.push({
+          from: column.tableName,
+          to: table.name,
+          type: RELATION.ONE_TO_MANY,
+          comment: "reference"
+        });
+      }
+      if (column.type === "module" || column.type === "module-array") {
+        const module2 = config.tableModules?.find(
+          (m) => m.name === column.moduleName
+        );
+        if (!module2) {
+          continue;
+        }
+        const moduleTableName = `${table.name}_${column.name}_${column.moduleName}`;
+        modules.push({
+          name: moduleTableName,
+          columns: module2?.columns.map((c) => ({
+            name: c.name,
+            type: c.type,
+            isForeignKey: c.type === "reference"
+          })) || []
+        });
+        relations.push({
+          from: table.name,
+          to: moduleTableName,
+          type: column.type === "module" ? RELATION.ONE_TO_ONE : RELATION.ONE_TO_MANY,
+          comment: column.type === "module" ? "module" : "module-array"
+        });
+        for (const moduleColumn of module2.columns) {
+          if (moduleColumn.type === "reference" && moduleColumn.tableName) {
+            relations.push({
+              from: moduleTableName,
+              to: moduleColumn.tableName,
+              type: RELATION.ONE_TO_MANY,
+              comment: "reference"
+            });
+          }
+        }
+      }
+    }
+    tables.push(erdTable);
+    tables.push(...modules);
+  }
+  return {
+    tables,
+    relations
+  };
+}
+var RELATION = {
+  ONE_TO_MANY: "||--o{",
+  ONE_TO_ONE: "||--||"
+};
+
+// src/config/generate-erd/command.ts
+var generateErdCommand = new import_commander7.Command("generate-erd").description("generate er diagram in mermaid format from orizm.config.ts").option("-c, --config <path>", "orizm config file path.", "orizm.config.ts").action(async (options) => {
+  try {
+    const config = await loadConfig(options.config);
+    const input2 = convertToInput(config);
+    const mermaidText = generate3(input2);
+    console.log(mermaidText);
+  } catch (error2) {
+    handleError(error2);
+  }
+});
+
+// src/cli.ts
+import_commander8.program.name("orizm CLI");
+import_commander8.program.addCommand(pushCommand);
+var cmsCommands = new import_commander8.Command("cms").description("cms commands.");
+cmsCommands.addCommand(cmsGenerateCommand);
+cmsCommands.addCommand(cmsPullCommand);
+import_commander8.program.addCommand(cmsCommands);
+var consumerCommands = new import_commander8.Command("consumer").description(
+  "consumer commands."
+);
+consumerCommands.addCommand(consumerGenerateCommand);
+consumerCommands.addCommand(consumerPullCommand);
+import_commander8.program.addCommand(consumerCommands);
+var configCommands = new import_commander8.Command("config").description("config commands.");
+configCommands.addCommand(validateConfigCommand);
+configCommands.addCommand(generateErdCommand);
+import_commander8.program.addCommand(configCommands);
+import_commander8.program.parse();