@orizm/cli 2.2.6 → 3.0.0

package/dist/cli.js

@@ -1,1954 +0,0 @@
-// src/cli.ts
-import { Command as Command8, program } from "commander";
-
-// src/cms/generate/command.ts
-import { Command } from "commander";
-
-// src/lib/load-config.ts
-import esbuild from "esbuild";
-import { OrizmConfigDef } from "@orizm/common/config-validator";
-import * as v from "valibot";
-async function loadConfig(configFile) {
-  const buildResult = await esbuild.build({
-    entryPoints: [configFile],
-    bundle: true,
-    write: false,
-    format: "esm",
-    target: "node22",
-    platform: "node"
-  });
-  const moduleURL = `data:text/javascript,${encodeURIComponent(
-    buildResult.outputFiles[0].text
-  )}`;
-  const { default: orizmConfigRaw } = await import(moduleURL);
-  return v.parse(OrizmConfigDef, orizmConfigRaw);
-}
-
-// src/lib/cli-spinner.ts
-import readline from "readline";
-
-// src/lib/cli-symbol.ts
-import chalk from "chalk";
-var success = chalk.green("\u2713");
-var error = chalk.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;
-    }
-    readline.clearLine(process.stdout, 0);
-    readline.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;
-    readline.clearLine(process.stdout, 0);
-    readline.cursorTo(process.stdout, 0);
-    process.stdout.write(`${frame} ${this.text}`);
-  }
-};
-function createSpinner() {
-  return new Spinner();
-}
-
-// src/lib/handle-error.ts
-import * as v3 from "valibot";
-import chalk3 from "chalk";
-
-// src/lib/display-valibot-error.ts
-import * as v2 from "valibot";
-import chalk2 from "chalk";
-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 ? chalk2.red(message) : message;
-}
-function getLocationPath(path3, color) {
-  return color ? chalk2.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 != null && 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(
-    chalk3.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
-import { mkdir, writeFile } from "fs/promises";
-import path from "path";
-
-// src/lib/format-ts-with-prettier.ts
-import * as prettier from "prettier/standalone";
-import prettierPluginEstree from "prettier/plugins/estree.js";
-import prettierPluginTypeScript from "prettier/plugins/typescript.js";
-function formatTsWithPrettier(code) {
-  return prettier.format(code, {
-    parser: "typescript",
-    plugins: [prettierPluginEstree, prettierPluginTypeScript]
-  });
-}
-
-// src/lib/render-helpers.ts
-function toCodeTypeName(str) {
-  str = str.charAt(0).toUpperCase() + str.slice(1);
-  return str.replace(/_([a-z])/g, (g) => g[1].toUpperCase());
-}
-function typeName(column, moduleSuffix = "") {
-  switch (column.type) {
-    case "reference":
-      return "string";
-    case "module":
-      return toCodeTypeName(column.moduleName ?? "") + moduleSuffix;
-    case "module-array":
-      return toCodeTypeName(column.moduleName ?? "") + moduleSuffix + "[]";
-    case "json":
-      return "unknown";
-    case "storage":
-      return "StorageItemType";
-    default:
-      return column.type;
-  }
-}
-function nullableSuffix(column) {
-  return !column.required && column.type !== "module-array" ? " | null" : "";
-}
-function filterRefColumns(columns) {
-  return columns.filter(
-    (c) => c.type === "reference" && c.tableName !== void 0 && c.includeName !== void 0 && c.includeName !== "" || c.type === "module" && c.moduleName !== void 0 || c.type === "module-array" && c.moduleName !== void 0
-  );
-}
-function getIncludeName(column) {
-  return column.type === "reference" ? column.includeName || column.name : column.name;
-}
-function getIncludeType(column) {
-  if (column.type === "reference" && column.tableName) {
-    return toCodeTypeName(column.tableName) + "__Descriptor";
-  }
-  if (column.type === "module" && column.moduleName) {
-    return `_ModuleRef<${toCodeTypeName(column.moduleName)}__Descriptor>`;
-  }
-  if (column.type === "module-array" && column.moduleName) {
-    return `_ArrayModuleRef<${toCodeTypeName(column.moduleName)}__Descriptor>`;
-  }
-  return "";
-}
-function renderColumnField(col, options) {
-  const optional2 = options?.optional === true ? "?" : "";
-  const suffix = options?.suffix ?? "";
-  return `${col.name}${optional2}: ${typeName(col, suffix)}${nullableSuffix(col)};`;
-}
-function renderTypeBlock(name, fields) {
-  return `export type ${name} = {
-${fields.join("\n")}
-};`;
-}
-function renderRefsFieldLines(columns) {
-  const refCols = filterRefColumns(columns);
-  if (refCols.length === 0) return ["refs: object;"];
-  return [
-    "refs: {",
-    ...refCols.map((c) => `${getIncludeName(c)}: ${getIncludeType(c)};`),
-    "}"
-  ];
-}
-function renderUniqueFieldLines(table) {
-  const uniqueIndexes = (table.indexes ?? []).filter((i) => i.unique);
-  if (uniqueIndexes.length === 0) return ["unique: [];"];
-  const entries = uniqueIndexes.map((index) => {
-    const cols = index.columns.map((colName) => {
-      const col = table.columns.find((c) => c.name === colName);
-      if (!col) throw new Error(`column ${colName} not found`);
-      const nullable = !col.required && index.nullsNotDistinct ? " | null" : "";
-      return `${col.name}:${typeName(col)}${nullable},`;
-    });
-    return `{ ${cols.join("")} },`;
-  });
-  return ["unique: [", ...entries, "]"];
-}
-function renderModuleRowTypeBlock(mod) {
-  return renderTypeBlock(toCodeTypeName(mod.name), [
-    "id: string;",
-    ...mod.columns.map((col) => renderColumnField(col))
-  ]);
-}
-function renderModuleDescriptorBlock(mod) {
-  const name = toCodeTypeName(mod.name);
-  return renderTypeBlock(`${name}__Descriptor`, [
-    `row: ${name};`,
-    ...renderRefsFieldLines(mod.columns),
-    "unique: [];"
-  ]);
-}
-function renderPreamble(importFrom) {
-  return `//  This file was automatically generated and should not be edited.
-
-import { FormValidationRules, StorageItemType } from "${importFrom}";
-
-// Utilities
-type _ModuleRef<T> = T & _ModuleDescriptor;
-type _ModuleDescriptor = {
-    isModule: true;
-};
-type _ArrayModuleRef<T> = T & _ArrayModuleDescriptor;
-type _ArrayModuleDescriptor = {
-    isModuleArray: true;
-};`;
-}
-function renderSection(title, blocks) {
-  if (blocks.length === 0) return "";
-  return `// ${title}
-${blocks.join("\n\n")}`;
-}
-function renderWebhookTypesSection(tables) {
-  const lines = [
-    "// Webhook types",
-    'export type WebhookEvent = "content.create" | "content.update" | "content.delete";',
-    "",
-    "type WebhookPayloadBase = {",
-    "  event: WebhookEvent;",
-    "  timestamp: string;",
-    "  project: string;",
-    "};",
-    ""
-  ];
-  if (tables.length > 0) {
-    const unionMembers = tables.map((t) => {
-      const name = toCodeTypeName(t.name);
-      return `| {
-  table: "${t.name}";
-  content: ${name};
-  old?: ${name};
-}`;
-    }).join("\n");
-    lines.push(
-      `export type WebhookPayload = WebhookPayloadBase & (
-${unionMembers}
-);`
-    );
-  } else {
-    lines.push("export type WebhookPayload = WebhookPayloadBase;");
-  }
-  return lines.join("\n");
-}
-
-// src/cms/generate/generator.ts
-async function generate(options) {
-  const config = options.config;
-  await mkdir(options.output, { recursive: true });
-  const renderedTypes = await renderTypes(config);
-  await writeFile(
-    path.join(options.output, "types.ts"),
-    renderedTypes,
-    "utf-8"
-  );
-  const renderedClient = await renderClient(config);
-  await writeFile(
-    path.join(options.output, "client.ts"),
-    renderedClient,
-    "utf-8"
-  );
-}
-async function renderTypes(config) {
-  const submissionTables = config.tables.filter((t) => t.enableForm).map((t) => ({
-    name: t.name + "__submission",
-    columns: t.formOptions?.submissionColumns ?? [],
-    isSubmissions: true
-  }));
-  const allTables = [...config.tables, ...submissionTables];
-  const modules = config.tableModules ?? [];
-  const source = [
-    renderPreamble("@orizm/cms-sdk/common"),
-    renderSection("Tables", allTables.map(renderTableTypes)),
-    renderSection("Module types", modules.map(renderModuleTypes)),
-    // CMS: モジュール descriptor 間は空行なし（スナップショット互換）
-    "// Descriptor types\n" + [
-      ...allTables.map(renderTableDescriptor),
-      modules.map(renderModuleDescriptorBlock).join("\n")
-    ].join("\n\n"),
-    renderWebhookTypesSection(allTables)
-  ].filter(Boolean).join("\n\n\n");
-  return await formatTsWithPrettier(source);
-}
-function renderTableTypes(table) {
-  const cols = table.columns;
-  const name = toCodeTypeName(table.name);
-  const rowType = renderTypeBlock(name, [
-    "id: string;",
-    "createdAt: string;",
-    "updatedAt: string;",
-    ...!table.isSubmissions ? [
-      "group: string | null;",
-      "publishedAt: string | null;",
-      "_draft: boolean | null;",
-      "_published: boolean | null;",
-      "scheduledPublishAt: string | null;",
-      "scheduledUnpublishAt: string | null;"
-    ] : [
-      "_formId: string;",
-      "_content: unknown;",
-      "_formSchema: unknown;",
-      "_attachments: StorageItemType[];"
-    ],
-    ...cols.map((col) => renderColumnField(col)),
-    ...table.enableForm ? ["formSchema: FormValidationRules;"] : []
-  ]);
-  const createType = renderTypeBlock(`${name}CreateInput`, [
-    ...!table.isSubmissions ? [
-      "group?: string | null;",
-      "publishedAt?: string | null;",
-      "scheduledPublishAt?: string | null;",
-      "scheduledUnpublishAt?: string | null;",
-      "createdAt?: string;"
-    ] : [],
-    ...cols.map(
-      (col) => renderColumnField(col, {
-        optional: !col.required,
-        suffix: "CreateInput"
-      })
-    ),
-    ...table.enableForm ? ["formSchema: FormValidationRules;"] : []
-  ]);
-  const updateType = renderTypeBlock(`${name}UpdateInput`, [
-    ...cols.filter((col) => !col.readOnly).map(
-      (col) => renderColumnField(col, { optional: true, suffix: "UpdateInput" })
-    ),
-    ...!table.isSubmissions ? [
-      "publishedAt?: string | null;",
-      "scheduledPublishAt?: string | null;",
-      "scheduledUnpublishAt?: string | null;",
-      "createdAt?: string;"
-    ] : [],
-    ...table.enableForm ? ["formSchema: FormValidationRules;"] : []
-  ]);
-  return [rowType, createType, updateType].join("\n\n");
-}
-function renderModuleTypes(mod) {
-  const name = toCodeTypeName(mod.name);
-  const cols = mod.columns;
-  const rowType = renderModuleRowTypeBlock(mod);
-  const createType = renderTypeBlock(`${name}CreateInput`, [
-    ...cols.map(
-      (col) => renderColumnField(col, {
-        optional: !col.required,
-        suffix: "CreateInput"
-      })
-    )
-  ]);
-  const updateType = renderTypeBlock(`${name}UpdateInput`, [
-    "id?: string;",
-    ...cols.map(
-      (col) => renderColumnField(col, {
-        optional: !col.required,
-        suffix: "UpdateInput"
-      })
-    )
-  ]);
-  return [rowType, createType, updateType].join("\n\n");
-}
-function renderTableDescriptor(table) {
-  const name = toCodeTypeName(table.name);
-  return renderTypeBlock(`${name}__Descriptor`, [
-    `row: ${name};`,
-    `create: ${name}CreateInput;`,
-    `update: ${name}UpdateInput;`,
-    ...renderRefsFieldLines(table.columns),
-    ...renderUniqueFieldLines(table),
-    ...table.enableDrafts ? ["enableDrafts: true;"] : [],
-    ...table.enableForm ? [`submissionDescriptor: ${name}_Submission__Descriptor;`] : ["submissionDescriptor: never;"]
-  ]);
-}
-async function renderClient(config) {
-  const tableEntries = config.tables.map(
-    (t) => `${t.name}: this.client.getTableClient<Models.${toCodeTypeName(t.name)}__Descriptor>("${t.name}"),`
-  ).join("\n");
-  const bucketEntries = (config.buckets ?? []).map((b) => `${b.name}: this.client.getBucketClient("${b.name}"),`).join("\n");
-  const source = `//  This file was automatically generated and should not be edited.
-
-import { OrizmCMSClient } from "@orizm/cms-sdk";
-
-import * as Models from "./types";
-
-export class CMSClient {
-  constructor(protected client: OrizmCMSClient) {
-    this.tables = {
-      ${tableEntries}
-    };
-
-    this.buckets = {
-      ${bucketEntries}
-    };
-
-    this.userManagement = this.client.userManagement;
-
-    this.userinfo = this.client.userinfo;
-
-    this.auth = this.client.auth;
-  }
-
-  readonly tables;
-  readonly buckets;
-  readonly userManagement;
-  readonly userinfo;
-  readonly auth;
-}
-`;
-  return await formatTsWithPrettier(source);
-}
-
-// src/cms/generate/command.ts
-var spinner = createSpinner();
-var cmsGenerateCommand = new 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
-import { Command as Command2 } from "commander";
-
-// ../internal-shared/dist/chunk-TTAO2AN2.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,
-    pathSerializer: globalPathSerializer,
-    headers: baseHeaders,
-    requestInitExt = void 0,
-    ...baseOptions
-  } = { ...clientOptions };
-  requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
-  baseUrl = removeTrailingSlash(baseUrl);
-  const globalMiddlewares = [];
-  async function coreFetch(schemaPath, fetchOptions) {
-    const {
-      baseUrl: localBaseUrl,
-      fetch = baseFetch,
-      Request = CustomRequest,
-      headers,
-      params = {},
-      parseAs = "json",
-      querySerializer: requestQuerySerializer,
-      bodySerializer = globalBodySerializer ?? defaultBodySerializer,
-      pathSerializer: requestPathSerializer,
-      body,
-      middleware: requestMiddlewares = [],
-      ...init
-    } = fetchOptions || {};
-    let finalBaseUrl = baseUrl;
-    if (localBaseUrl) {
-      finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
-    }
-    let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
-    if (requestQuerySerializer) {
-      querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
-        ...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
-        ...requestQuerySerializer
-      });
-    }
-    const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
-    const serializedBody = body === void 0 ? void 0 : bodySerializer(
-      body,
-      // Note: we declare mergeHeaders() both here and below because it’s a bit of a chicken-or-egg situation:
-      // bodySerializer() needs all headers so we aren’t dropping ones set by the user, however,
-      // the result of this ALSO sets the lowest-priority content-type header. So we re-merge below,
-      // setting the content-type at the very beginning to be overwritten.
-      // Lastly, based on the way headers work, it’s not a simple “present-or-not” check becauase null intentionally un-sets headers.
-      mergeHeaders(baseHeaders, headers, params.header)
-    );
-    const finalHeaders = mergeHeaders(
-      // 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"
-      },
-      baseHeaders,
-      headers,
-      params.header
-    );
-    const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
-    const requestInit = {
-      redirect: "follow",
-      ...baseOptions,
-      ...init,
-      body: serializedBody,
-      headers: finalHeaders
-    };
-    let id;
-    let options;
-    let request = new Request(
-      createFinalURL(schemaPath, { baseUrl: finalBaseUrl, params, querySerializer, pathSerializer }),
-      requestInit
-    );
-    let response;
-    for (const key in init) {
-      if (!(key in request)) {
-        request[key] = init[key];
-      }
-    }
-    if (finalMiddlewares.length) {
-      id = randomID();
-      options = Object.freeze({
-        baseUrl: finalBaseUrl,
-        fetch,
-        parseAs,
-        querySerializer,
-        bodySerializer,
-        pathSerializer
-      });
-      for (const m of finalMiddlewares) {
-        if (m && typeof m === "object" && typeof m.onRequest === "function") {
-          const result = await m.onRequest({
-            request,
-            schemaPath,
-            params,
-            options,
-            id
-          });
-          if (result) {
-            if (result instanceof Request) {
-              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 (error22) {
-        let errorAfterMiddleware = error22;
-        if (finalMiddlewares.length) {
-          for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
-            const m = finalMiddlewares[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 (finalMiddlewares.length) {
-        for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
-          const m = finalMiddlewares[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;
-            }
-          }
-        }
-      }
-    }
-    const contentLength = response.headers.get("Content-Length");
-    if (response.status === 204 || request.method === "HEAD" || contentLength === "0" && !response.headers.get("Transfer-Encoding")?.includes("chunked")) {
-      return response.ok ? { data: void 0, response } : { error: void 0, response };
-    }
-    if (response.ok) {
-      const getResponseData = async () => {
-        if (parseAs === "stream") {
-          return response.body;
-        }
-        if (parseAs === "json" && !contentLength) {
-          const raw = await response.text();
-          return raw ? JSON.parse(raw) : void 0;
-        }
-        return await response[parseAs]();
-      };
-      return { data: await getResponseData(), 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()`");
-        }
-        globalMiddlewares.push(m);
-      }
-    },
-    /** Unregister middleware */
-    eject(...middleware) {
-      for (const m of middleware) {
-        const i = globalMiddlewares.indexOf(m);
-        if (i !== -1) {
-          globalMiddlewares.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, headers) {
-  if (body instanceof FormData) {
-    return body;
-  }
-  if (headers) {
-    const contentType = headers.get instanceof Function ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"];
-    if (contentType === "application/x-www-form-urlencoded") {
-      return new URLSearchParams(body).toString();
-    }
-  }
-  return JSON.stringify(body);
-}
-function createFinalURL(pathname, options) {
-  let finalURL = `${options.baseUrl}${pathname}`;
-  if (options.params?.path) {
-    finalURL = options.pathSerializer(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;
-}
-function assertValidUrlOrigin(origin) {
-  const url = new URL(origin);
-  if (url.origin !== origin) {
-    throw new Error(`${origin} is not a valid URL origin`);
-  }
-}
-
-// ../internal-shared/dist/api-clients/dev-v2-api-client.js
-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
-import fs from "fs/promises";
-import * as v4 from "valibot";
-import dotenv from "dotenv";
-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 fs.readFile(envPath, "utf-8").catch(() => null);
-    if (!envFileContent) {
-      throw new Error(`Environment variables file: '${envPath}' is not found.`);
-    }
-  } else {
-    envFileContent = await fs.readFile(DEFAULT_ENV_FILE_PATH, "utf-8").catch(() => null);
-  }
-  if (envFileContent !== null) {
-    const dotenvParsed = dotenv.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 Command2("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
-import { Command as Command3 } from "commander";
-
-// src/consumer/pull/generate.ts
-import { mkdir as mkdir2, writeFile as writeFile2 } from "fs/promises";
-import path2 from "path";
-async function generate2(options) {
-  await mkdir2(options.output, { recursive: true });
-  const renderedTypes = await renderTypes2(options.definition);
-  const targetTypesPath = path2.join(options.output, "types.ts");
-  await writeFile2(targetTypesPath, renderedTypes, "utf-8");
-  const renderedClient = await renderClient2(options.definition);
-  const targetClientPath = path2.join(options.output, "client.ts");
-  await writeFile2(targetClientPath, renderedClient, "utf-8");
-}
-async function renderTypes2(config) {
-  const tables = config.tables;
-  const modules = config.tableModules ?? [];
-  const source = [
-    renderPreamble("@orizm/consumer-sdk/common"),
-    renderSection("Tables", tables.map(renderTableRowType)),
-    modules.map(renderModuleRowTypeBlock).join("\n\n"),
-    renderSection("Descriptor types", [
-      ...tables.map(renderTableDescriptor2),
-      ...modules.map(renderModuleDescriptorBlock)
-    ]),
-    renderWebhookTypesSection(tables)
-  ].filter(Boolean).join("\n\n\n");
-  return await formatTsWithPrettier(source);
-}
-function renderTableRowType(table) {
-  return renderTypeBlock(toCodeTypeName(table.name), [
-    "id: string;",
-    "createdAt: string;",
-    "updatedAt: string;",
-    "group: string | null;",
-    "publishedAt: string | null;",
-    "_draft: boolean | null;",
-    "_published: boolean | null;",
-    ...table.columns.map((col) => renderColumnField(col)),
-    ...table.enableForm ? ["formSchema: FormValidationRules;"] : []
-  ]);
-}
-function renderTableDescriptor2(table) {
-  const name = toCodeTypeName(table.name);
-  return renderTypeBlock(`${name}__Descriptor`, [
-    `row: ${name};`,
-    ...renderRefsFieldLines(table.columns),
-    ...renderUniqueFieldLines(table),
-    ...table.enableDrafts ? ["enableDrafts: true;"] : []
-  ]);
-}
-async function renderClient2(config) {
-  const tableEntries = config.tables.map(
-    (t) => `${t.name}: this.getTableClient<Models.${toCodeTypeName(t.name)}__Descriptor>("${t.name}"),`
-  ).join("\n");
-  const source = `//  This file was automatically generated and should not be edited.
-
-import { ConsumerClientOptions, OrizmConsumerClientBase } from "@orizm/consumer-sdk";
-import * as Models from "./types";
-
-export class OrizmClient extends OrizmConsumerClientBase {
-  constructor(options: ConsumerClientOptions) {
-    super(options);
-  }
-
-  readonly tables = {
-    ${tableEntries}
-  };
-}
-`;
-  return await formatTsWithPrettier(source);
-}
-
-// 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 Command3("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
-import { Command as Command4 } from "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 Command4("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
-import { Command as Command5 } from "commander";
-import chalk6 from "chalk";
-
-// src/lib/developer-api.ts
-import chalk4 from "chalk";
-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."
-      );
-    }
-    if (response.error.type === "bad-request") {
-      console.log(chalk4.red(response.error.detail));
-      process.exit(1);
-    }
-    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
-import chalk5 from "chalk";
-
-// 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] == null || 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
-function displayChangeEvents(changeEvents) {
-  const {
-    tableChangeEvents = [],
-    bucketChangeEvents = [],
-    authorityChangeEvents = []
-  } = changeEvents;
-  if (tableChangeEvents.length === 0 && bucketChangeEvents.length === 0 && authorityChangeEvents.length === 0) {
-    console.log();
-    console.log(chalk5.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 "draft:enable": {
-          table.addRow(["table", event.tableDef.name, eventName, ""], {
-            color: "green"
-          });
-          break;
-        }
-        case "draft: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
-import { createInterface } from "readline/promises";
-async function input(prompt) {
-  const rl = 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 Command5("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(chalk6.red("Canceled."));
-          return;
-        }
-      }
-      spinner5.start("Applying schema...");
-      await applyDefinition(env, projectDef);
-      spinner5.succeed("Schema applied.");
-    } catch (error2) {
-      handleError(error2);
-    }
-  }
-);
-
-// src/config/validate/command.ts
-import { Command as Command6 } from "commander";
-import chalk7 from "chalk";
-import * as v5 from "valibot";
-
-// src/config/validate/watcher.ts
-import chokidar from "chokidar";
-function watchConfigFile(configPath, onFileChange) {
-  const watcher = chokidar.watch(configPath, {
-    persistent: true,
-    ignoreInitial: true
-  });
-  let isProcessing = false;
-  let timeoutId = null;
-  const debouncedOnChange = () => {
-    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 Command6("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(chalk7.green("\u2705 Config is valid."));
-      } catch (error2) {
-        if (v5.isValiError(error2)) {
-          console.error(chalk7.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
-import { Command as Command7 } from "commander";
-
-// src/config/generate-erd/generate.ts
-function generate3(input2) {
-  const tables = input2.tables.map((table) => {
-    const columns = [
-      "        id string PK",
-      ...table.columns.map(
-        (col) => `        ${col.name} ${col.type}${col.isForeignKey ? " FK" : ""}`
-      )
-    ].join("\n");
-    return `    ${table.name} {
-${columns}
-    }`;
-  }).join("\n");
-  const relations = input2.relations.map((rel) => `    ${rel.from} ${rel.type} ${rel.to} : ${rel.comment}`).join("\n");
-  return `generated by @orizm/cli
-
-\`\`\`mermaid
-erDiagram
-${tables}
-
-${relations}
-\`\`\``;
-}
-
-// src/config/generate-erd/convert-to-input.ts
-function convertToInput(config) {
-  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 module = config.tableModules?.find(
-          (m) => m.name === column.moduleName
-        );
-        if (!module) {
-          continue;
-        }
-        const moduleTableName = `${table.name}_${column.name}_${column.moduleName}`;
-        modules.push({
-          name: moduleTableName,
-          columns: module.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 module.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 Command7("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
-program.name("orizm CLI");
-program.addCommand(pushCommand);
-var cmsCommands = new Command8("cms").description("cms commands.");
-cmsCommands.addCommand(cmsGenerateCommand);
-cmsCommands.addCommand(cmsPullCommand);
-program.addCommand(cmsCommands);
-var consumerCommands = new Command8("consumer").description(
-  "consumer commands."
-);
-consumerCommands.addCommand(consumerGenerateCommand);
-consumerCommands.addCommand(consumerPullCommand);
-program.addCommand(consumerCommands);
-var configCommands = new Command8("config").description("config commands.");
-configCommands.addCommand(validateConfigCommand);
-configCommands.addCommand(generateErdCommand);
-program.addCommand(configCommands);
-program.parse();
-//# sourceMappingURL=cli.js.map