@onyx.dev/onyx-database 0.1.4

package/dist/gen/cli/generate.cjs

@@ -0,0 +1,796 @@
+#!/usr/bin/env node
+'use strict';
+
+var process = require('process');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var process__default = /*#__PURE__*/_interopDefault(process);
+
+// src/config/defaults.ts
+var DEFAULT_BASE_URL = "https://api.onyx.dev";
+var sanitizeBaseUrl = (u) => u.replace(/\/+$/, "");
+
+// src/errors/config-error.ts
+var OnyxConfigError = class extends Error {
+  name = "OnyxConfigError";
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/config/chain.ts
+var gProcess = globalThis.process;
+var isNode = !!gProcess?.versions?.node;
+var dbg = (...args) => {
+  if (gProcess?.env?.ONYX_DEBUG == "true") {
+    const fmt = (v) => {
+      if (typeof v === "string") return v;
+      try {
+        return JSON.stringify(v);
+      } catch {
+        return String(v);
+      }
+    };
+    gProcess.stderr?.write?.(`[onyx-config] ${args.map(fmt).join(" ")}
+`);
+  }
+};
+function dropUndefined(obj) {
+  if (!obj) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== void 0) out[k] = v;
+  }
+  return out;
+}
+function readEnv(targetId) {
+  if (!gProcess?.env) return {};
+  const env = gProcess.env;
+  const pick = (...keys) => {
+    for (const k of keys) {
+      const v = env[k];
+      if (typeof v === "string") {
+        const cleaned = v.replace(/[\r\n]+/g, "").trim();
+        if (cleaned !== "") return cleaned;
+      }
+    }
+    return void 0;
+  };
+  const envId = pick("ONYX_DATABASE_ID");
+  if (targetId && envId !== targetId) return {};
+  const res = dropUndefined({
+    baseUrl: pick("ONYX_DATABASE_BASE_URL"),
+    databaseId: envId,
+    apiKey: pick("ONYX_DATABASE_API_KEY"),
+    apiSecret: pick("ONYX_DATABASE_API_SECRET")
+  });
+  if (Object.keys(res).length === 0) return {};
+  dbg("env:", mask(res));
+  return res;
+}
+async function readProjectFile(databaseId) {
+  if (!isNode) return {};
+  const fs = await import('fs/promises');
+  const path = await import('path');
+  const cwd = gProcess?.cwd?.() ?? ".";
+  const tryRead = async (p) => {
+    const txt = await fs.readFile(p, "utf8");
+    const sanitized = txt.replace(/[\r\n]+/g, "");
+    const json = dropUndefined(JSON.parse(sanitized));
+    dbg("project file:", p, "\u2192", mask(json));
+    return json;
+  };
+  if (databaseId) {
+    const specific = path.resolve(cwd, `onyx-database-${databaseId}.json`);
+    try {
+      return await tryRead(specific);
+    } catch {
+      dbg("project file not found:", specific);
+    }
+  }
+  const fallback = path.resolve(cwd, "onyx-database.json");
+  try {
+    return await tryRead(fallback);
+  } catch {
+    dbg("project file not found:", fallback);
+    return {};
+  }
+}
+async function readHomeProfile(databaseId) {
+  if (!isNode) return {};
+  const fs = await import('fs/promises');
+  const os = await import('os');
+  const path = await import('path');
+  const home = os.homedir();
+  const dir = path.join(home, ".onyx");
+  const fileExists = async (p) => {
+    try {
+      await fs.access(p);
+      return true;
+    } catch {
+      return false;
+    }
+  };
+  const readProfile = async (p) => {
+    try {
+      const txt = await fs.readFile(p, "utf8");
+      const sanitized = txt.replace(/[\r\n]+/g, "");
+      const json = dropUndefined(JSON.parse(sanitized));
+      dbg("home profile used:", p, "\u2192", mask(json));
+      return json;
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      throw new OnyxConfigError(`Failed to read ${p}: ${msg}`);
+    }
+  };
+  if (databaseId) {
+    const specific = `${dir}/onyx-database-${databaseId}.json`;
+    if (await fileExists(specific)) return readProfile(specific);
+    dbg("no specific profile:", specific);
+  }
+  const defaultInDir = `${dir}/onyx-database.json`;
+  if (await fileExists(defaultInDir)) return readProfile(defaultInDir);
+  dbg("no default profile in dir:", defaultInDir);
+  const defaultInHome = `${home}/onyx-database.json`;
+  if (await fileExists(defaultInHome)) return readProfile(defaultInHome);
+  dbg("no home-root fallback:", defaultInHome);
+  if (!await fileExists(dir)) {
+    dbg("~/.onyx does not exist:", dir);
+    return {};
+  }
+  const files = await fs.readdir(dir).catch(() => []);
+  const matches = files.filter((f) => f.startsWith("onyx-database-") && f.endsWith(".json"));
+  if (matches.length === 1) {
+    const only = `${dir}/${matches[0]}`;
+    return readProfile(only);
+  }
+  if (matches.length > 1) {
+    throw new OnyxConfigError(
+      "Multiple ~/.onyx/onyx-database-*.json profiles found. Specify databaseId via env or provide ./onyx-database.json."
+    );
+  }
+  dbg("no usable home profiles found in", dir);
+  return {};
+}
+async function readConfigPath(p) {
+  if (!isNode) return {};
+  const fs = await import('fs/promises');
+  const path = await import('path');
+  const cwd = gProcess?.cwd?.() ?? ".";
+  const resolved = path.isAbsolute(p) ? p : path.resolve(cwd, p);
+  try {
+    const txt = await fs.readFile(resolved, "utf8");
+    const sanitized = txt.replace(/[\r\n]+/g, "");
+    const json = dropUndefined(JSON.parse(sanitized));
+    dbg("config path:", resolved, "\u2192", mask(json));
+    return json;
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    throw new OnyxConfigError(`Failed to read ${resolved}: ${msg}`);
+  }
+}
+async function resolveConfig(input) {
+  const configPath = gProcess?.env?.ONYX_CONFIG_PATH;
+  const env = readEnv(input?.databaseId);
+  let cfgPath = {};
+  if (configPath) {
+    cfgPath = await readConfigPath(configPath);
+  }
+  const targetId = input?.databaseId ?? env.databaseId ?? cfgPath.databaseId;
+  let haveDbId = !!(input?.databaseId ?? env.databaseId ?? cfgPath.databaseId);
+  let haveApiKey = !!(input?.apiKey ?? env.apiKey ?? cfgPath.apiKey);
+  let haveApiSecret = !!(input?.apiSecret ?? env.apiSecret ?? cfgPath.apiSecret);
+  let project = {};
+  if (!(haveDbId && haveApiKey && haveApiSecret)) {
+    project = await readProjectFile(targetId);
+    if (project.databaseId) haveDbId = true;
+    if (project.apiKey) haveApiKey = true;
+    if (project.apiSecret) haveApiSecret = true;
+  }
+  let home = {};
+  if (!(haveDbId && haveApiKey && haveApiSecret)) {
+    home = await readHomeProfile(targetId);
+  }
+  const merged = {
+    baseUrl: DEFAULT_BASE_URL,
+    ...dropUndefined(home),
+    ...dropUndefined(project),
+    ...dropUndefined(cfgPath),
+    ...dropUndefined(env),
+    ...dropUndefined(input)
+  };
+  dbg("merged (pre-validate):", mask(merged));
+  const baseUrl = sanitizeBaseUrl(merged.baseUrl ?? DEFAULT_BASE_URL);
+  const databaseId = merged.databaseId ?? "";
+  const apiKey = merged.apiKey ?? "";
+  const apiSecret = merged.apiSecret ?? "";
+  const gfetch = globalThis.fetch;
+  const fetchImpl = merged.fetch ?? (typeof gfetch === "function" ? (u, i) => gfetch(u, i) : async () => {
+    throw new OnyxConfigError("No fetch available; provide OnyxConfig.fetch");
+  });
+  const missing = [];
+  if (!databaseId) missing.push("databaseId");
+  if (!apiKey) missing.push("apiKey");
+  if (!apiSecret) missing.push("apiSecret");
+  if (missing.length) {
+    dbg("validation failed. merged:", mask(merged));
+    const sources = [
+      "env",
+      configPath ?? "env ONYX_CONFIG_PATH",
+      ...isNode ? [
+        "./onyx-database-<databaseId>.json",
+        "./onyx-database.json",
+        "~/.onyx/onyx-database-<databaseId>.json",
+        "~/.onyx/onyx-database.json",
+        "~/onyx-database.json"
+      ] : [],
+      "explicit config"
+    ];
+    throw new OnyxConfigError(
+      `Missing required config: ${missing.join(", ")}. Sources: ${sources.join(", ")}`
+    );
+  }
+  const resolved = { baseUrl, databaseId, apiKey, apiSecret, fetch: fetchImpl };
+  const source = {
+    databaseId: input?.databaseId ? "explicit config" : env.databaseId ? "env" : cfgPath.databaseId ? "env ONYX_CONFIG_PATH" : project.databaseId ? "project file" : home.databaseId ? "home profile" : "unknown",
+    apiKey: input?.apiKey ? "explicit config" : env.apiKey ? "env" : cfgPath.apiKey ? "env ONYX_CONFIG_PATH" : project.apiKey ? "project file" : home.apiKey ? "home profile" : "unknown",
+    apiSecret: input?.apiSecret ? "explicit config" : env.apiSecret ? "env" : cfgPath.apiSecret ? "env ONYX_CONFIG_PATH" : project.apiSecret ? "project file" : home.apiSecret ? "home profile" : "unknown"
+  };
+  dbg("credential source:", JSON.stringify(source));
+  dbg("resolved:", mask(resolved));
+  return resolved;
+}
+function mask(obj) {
+  if (!obj) return obj;
+  const clone = { ...obj };
+  if (typeof clone.apiKey === "string") clone.apiKey = "***";
+  if (typeof clone.apiSecret === "string") clone.apiSecret = "***";
+  return clone;
+}
+
+// src/errors/http-error.ts
+var OnyxHttpError = class extends Error {
+  name = "OnyxHttpError";
+  status;
+  statusText;
+  body;
+  rawBody;
+  constructor(message, status, statusText, body, rawBody) {
+    super(message);
+    this.status = status;
+    this.statusText = statusText;
+    this.body = body;
+    this.rawBody = rawBody;
+  }
+  toJSON() {
+    return {
+      name: this.name,
+      message: this.message,
+      status: this.status,
+      statusText: this.statusText,
+      body: this.body,
+      rawBody: this.rawBody,
+      stack: this.stack
+    };
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toJSON();
+  }
+};
+
+// src/core/http.ts
+function parseJsonAllowNaN(txt) {
+  try {
+    return JSON.parse(txt);
+  } catch {
+    const fixed = txt.replace(/(:\s*)(NaN|Infinity|-Infinity)(\s*[,}])/g, "$1null$3");
+    return JSON.parse(fixed);
+  }
+}
+var HttpClient = class {
+  baseUrl;
+  apiKey;
+  apiSecret;
+  fetchImpl;
+  defaults;
+  requestLoggingEnabled;
+  responseLoggingEnabled;
+  constructor(opts) {
+    if (!opts.baseUrl || opts.baseUrl.trim() === "") {
+      throw new OnyxConfigError("baseUrl is required");
+    }
+    try {
+      new URL(opts.baseUrl);
+    } catch {
+      throw new OnyxConfigError("baseUrl must include protocol, e.g. https://");
+    }
+    this.baseUrl = opts.baseUrl.replace(/\/+$/, "");
+    this.apiKey = opts.apiKey;
+    this.apiSecret = opts.apiSecret;
+    const gfetch = globalThis.fetch;
+    if (opts.fetchImpl) {
+      this.fetchImpl = opts.fetchImpl;
+    } else if (typeof gfetch === "function") {
+      this.fetchImpl = (url, init) => gfetch(url, init);
+    } else {
+      throw new Error("global fetch is not available; provide OnyxConfig.fetch");
+    }
+    this.defaults = Object.assign({}, opts.defaultHeaders);
+    const envDebug = globalThis.process?.env?.ONYX_DEBUG === "true";
+    this.requestLoggingEnabled = !!opts.requestLoggingEnabled || envDebug;
+    this.responseLoggingEnabled = !!opts.responseLoggingEnabled || envDebug;
+  }
+  headers(extra) {
+    const extras = { ...extra ?? {} };
+    delete extras["x-onyx-key"];
+    delete extras["x-onyx-secret"];
+    return {
+      "x-onyx-key": this.apiKey,
+      "x-onyx-secret": this.apiSecret,
+      "Accept": "application/json",
+      "Content-Type": "application/json",
+      ...this.defaults,
+      ...extras
+    };
+  }
+  async request(method, path, body, extraHeaders) {
+    if (!path.startsWith("/")) {
+      throw new OnyxConfigError("path must start with /");
+    }
+    const url = `${this.baseUrl}${path}`;
+    const headers = this.headers({
+      ...method === "DELETE" ? { Prefer: "return=representation" } : {},
+      ...extraHeaders ?? {}
+    });
+    if (body == null) delete headers["Content-Type"];
+    if (this.requestLoggingEnabled) {
+      console.log(`${method} ${url}`);
+      if (body != null) {
+        const logBody = typeof body === "string" ? body : JSON.stringify(body);
+        console.log(logBody);
+      }
+      const headerLog = { ...headers, "x-onyx-secret": "[REDACTED]" };
+      console.log("Headers:", headerLog);
+    }
+    const payload = body == null ? void 0 : typeof body === "string" ? body : JSON.stringify(body);
+    const init = {
+      method,
+      headers,
+      body: payload
+    };
+    const isQuery = path.includes("/query/") && !/\/query\/(?:update|delete)\//.test(path);
+    const canRetry = method === "GET" || isQuery;
+    const maxAttempts = canRetry ? 3 : 1;
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      try {
+        const res = await this.fetchImpl(url, init);
+        const contentType = res.headers.get("Content-Type") || "";
+        const raw = await res.text();
+        if (this.responseLoggingEnabled) {
+          const statusLine = `${res.status} ${res.statusText}`.trim();
+          console.log(statusLine);
+          if (raw.trim().length > 0) {
+            console.log(raw);
+          }
+        }
+        const isJson = raw.trim().length > 0 && (contentType.includes("application/json") || /^[\[{]/.test(raw.trim()));
+        const data = isJson ? parseJsonAllowNaN(raw) : raw;
+        if (!res.ok) {
+          const msg = typeof data === "object" && data !== null && "error" in data && typeof data.error?.message === "string" ? String(data.error.message) : `${res.status} ${res.statusText}`;
+          if (canRetry && res.status >= 500 && attempt + 1 < maxAttempts) {
+            await new Promise((r) => setTimeout(r, 100 * 2 ** attempt));
+            continue;
+          }
+          throw new OnyxHttpError(msg, res.status, res.statusText, data, raw);
+        }
+        return data;
+      } catch (err) {
+        const retryable = canRetry && (!(err instanceof OnyxHttpError) || err.status >= 500);
+        if (attempt + 1 < maxAttempts && retryable) {
+          await new Promise((r) => setTimeout(r, 100 * 2 ** attempt));
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw new Error("Request failed after retries");
+  }
+};
+
+// gen/emit.ts
+var DEFAULTS = {
+  schemaTypeName: "OnyxSchema",
+  timestampMode: "date",
+  modelNamePrefix: "",
+  optionalStrategy: "non-null"
+};
+function isValidIdentifier(name) {
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+}
+function toPascalCase(raw) {
+  const cleaned = String(raw).replace(/[^A-Za-z0-9]+/g, " ");
+  const pc = cleaned.trim().split(/\s+/).filter(Boolean).map((s) => s.charAt(0).toUpperCase() + s.slice(1)).join("");
+  return pc.length === 0 ? "Table" : /^[0-9]/.test(pc) ? `T${pc}` : pc;
+}
+function tsTypeFor(attrType, timestampMode) {
+  switch (attrType) {
+    case "String":
+      return "string";
+    case "Int":
+      return "number";
+    case "Boolean":
+      return "boolean";
+    case "Timestamp":
+      return timestampMode === "date" ? "Date" : timestampMode === "number" ? "number" : "string";
+    case "EmbeddedList":
+      return "any[]";
+    case "EmbeddedObject":
+      return "any";
+    default:
+      return "any";
+  }
+}
+function propertyLine(attr, timestampMode, optionalStrategy) {
+  const key = isValidIdentifier(attr.name) ? attr.name : JSON.stringify(attr.name);
+  const makeOptional = optionalStrategy === "non-null" ? !attr.isNullable : optionalStrategy === "nullable" ? attr.isNullable : false;
+  const t = tsTypeFor(attr.type, timestampMode);
+  const nullableUnion = attr.isNullable ? " | null" : "";
+  return `  ${key}${makeOptional ? "?" : ""}: ${t}${nullableUnion};`;
+}
+function emitTypes(schema, options) {
+  const opts = { ...DEFAULTS, ...options ?? {} };
+  const usedEnumKeys = /* @__PURE__ */ new Set();
+  const makeEnumKey = (raw) => {
+    const base = toPascalCase(raw);
+    let key = base;
+    let i = 2;
+    while (usedEnumKeys.has(key)) {
+      key = `${base}_${i++}`;
+    }
+    usedEnumKeys.add(key);
+    return key;
+  };
+  const lines = [];
+  lines.push(`// AUTO-GENERATED BY onyx-gen. DO NOT EDIT.`);
+  lines.push(`// Generated at ${(/* @__PURE__ */ new Date()).toISOString()}`);
+  lines.push("");
+  for (const t of schema.tables) {
+    const typeName = `${opts.modelNamePrefix}${toPascalCase(t.name)}`;
+    lines.push(`export interface ${typeName} {`);
+    for (const a of t.attributes) {
+      lines.push(propertyLine(a, opts.timestampMode, opts.optionalStrategy));
+    }
+    lines.push("  [key: string]: any;");
+    lines.push("}");
+    lines.push("");
+  }
+  lines.push(`export type ${opts.schemaTypeName} = {`);
+  for (const t of schema.tables) {
+    const key = isValidIdentifier(t.name) ? t.name : JSON.stringify(t.name);
+    const modelName = `${opts.modelNamePrefix}${toPascalCase(t.name)}`;
+    lines.push(`  ${key}: ${modelName};`);
+  }
+  lines.push("};");
+  lines.push("");
+  if (opts.schemaTypeName !== "Schema") {
+    lines.push(`export type Schema = ${opts.schemaTypeName};`);
+  }
+  lines.push(`export const Schema = {} as ${opts.schemaTypeName};`);
+  lines.push("");
+  lines.push("export enum tables {");
+  for (const t of schema.tables) {
+    const enumKey = makeEnumKey(t.name);
+    const enumVal = JSON.stringify(t.name);
+    lines.push(`  ${enumKey} = ${enumVal},`);
+  }
+  lines.push("}");
+  lines.push("");
+  return lines.join("\n");
+}
+
+// gen/generate.ts
+var DEFAULTS2 = {
+  source: "auto",
+  outBaseName: "onyx.schema",
+  emitJson: false,
+  overwrite: true,
+  timestampMode: "date",
+  schemaTypeName: "OnyxSchema",
+  optional: "non-null",
+  quiet: false
+};
+async function readFileJson(path) {
+  const fs = await import('fs/promises');
+  const txt = await fs.readFile(path, "utf8");
+  return JSON.parse(txt);
+}
+async function ensureDir(dir) {
+  const fs = await import('fs/promises');
+  await fs.mkdir(dir, { recursive: true });
+}
+async function writeFile(path, data, overwrite) {
+  const fs = await import('fs/promises');
+  if (!overwrite) {
+    try {
+      await fs.access(path);
+      throw new Error(`Refusing to overwrite existing file: ${path}`);
+    } catch {
+    }
+  }
+  await fs.writeFile(path, data, "utf8");
+}
+function isIntrospection(x) {
+  return !!x && typeof x === "object" && Array.isArray(x.tables);
+}
+async function fetchSchemaFromApi(http, databaseId, candidates) {
+  const defaultCandidates = [
+    `/schema/${encodeURIComponent(databaseId)}`,
+    `/data/${encodeURIComponent(databaseId)}/schema`,
+    `/meta/schema/${encodeURIComponent(databaseId)}`,
+    `/schema?databaseId=${encodeURIComponent(databaseId)}`,
+    `/meta/schema?databaseId=${encodeURIComponent(databaseId)}`
+  ];
+  const paths = candidates && candidates.length ? candidates : defaultCandidates;
+  let lastErr;
+  for (const p of paths) {
+    try {
+      const res = await http.request("GET", p);
+      if (isIntrospection(res)) return res;
+    } catch (e) {
+      lastErr = e;
+    }
+  }
+  const err = lastErr instanceof Error ? lastErr.message : String(lastErr ?? "Unknown error");
+  throw new Error(
+    `Unable to fetch schema from API. Tried: ${paths.join(", ")}. Last error: ${err}`
+  );
+}
+async function generateTypes(options) {
+  const path = await import('path');
+  const opts = { ...DEFAULTS2, ...options ?? {} };
+  const typesDir = opts.typesOutDir ?? opts.outDir ?? "generated";
+  let schema = null;
+  if (opts.source === "file" || opts.source === "auto" && opts.schemaPath) {
+    if (!opts.schemaPath) throw new Error('schemaPath is required when source="file"');
+    if (!opts.quiet)
+      process__default.default.stderr.write(`[onyx-gen] reading schema from file: ${opts.schemaPath}
+`);
+    schema = await readFileJson(opts.schemaPath);
+  }
+  if (!schema) {
+    if (opts.source === "file") throw new Error("Failed to read schema from file");
+    const cfg = await resolveConfig({});
+    const http = new HttpClient({
+      baseUrl: cfg.baseUrl,
+      apiKey: cfg.apiKey,
+      apiSecret: cfg.apiSecret,
+      fetchImpl: cfg.fetch
+    });
+    if (!opts.quiet)
+      process__default.default.stderr.write(`[onyx-gen] fetching schema from API for db ${cfg.databaseId}
+`);
+    schema = await fetchSchemaFromApi(http, cfg.databaseId, options?.apiPaths);
+  }
+  if (!isIntrospection(schema)) {
+    throw new Error('Invalid schema: missing "tables" array.');
+  }
+  const outIsFile = typeof opts.typesOutFile === "string" && (opts.typesOutFile.endsWith(".ts") || opts.typesOutFile.endsWith(".mts") || opts.typesOutFile.endsWith(".cts") || opts.typesOutFile.endsWith(".d.ts") || opts.typesOutFile.endsWith(".d.mts") || opts.typesOutFile.endsWith(".d.cts"));
+  let typesPath;
+  let jsonBaseName;
+  let typesDirAbs;
+  if (outIsFile) {
+    const typesOutFile = opts.typesOutFile;
+    typesPath = path.resolve(process__default.default.cwd(), typesOutFile);
+    typesDirAbs = path.dirname(typesPath);
+    await ensureDir(typesDirAbs);
+    jsonBaseName = path.basename(typesPath, path.extname(typesPath));
+  } else {
+    typesDirAbs = path.resolve(process__default.default.cwd(), typesDir);
+    await ensureDir(typesDirAbs);
+    typesPath = path.join(typesDirAbs, `${opts.outBaseName}.ts`);
+    jsonBaseName = opts.outBaseName;
+  }
+  const types = emitTypes(schema, {
+    schemaTypeName: opts.schemaTypeName,
+    timestampMode: opts.timestampMode,
+    modelNamePrefix: opts.prefix ?? "",
+    optionalStrategy: opts.optional
+  });
+  await writeFile(typesPath, `${types}
+`, opts.overwrite);
+  let jsonPath;
+  if (opts.emitJson) {
+    const jsonOutDirAbs = path.resolve(
+      process__default.default.cwd(),
+      opts.jsonOutDir ?? (outIsFile ? typesDirAbs : typesDirAbs)
+    );
+    await ensureDir(jsonOutDirAbs);
+    jsonPath = path.join(jsonOutDirAbs, `${jsonBaseName}.json`);
+    const jsonPretty = JSON.stringify(schema, null, 2);
+    await writeFile(jsonPath, `${jsonPretty}
+`, opts.overwrite);
+  }
+  if (!opts.quiet) {
+    process__default.default.stderr.write(`[onyx-gen] wrote ${typesPath}
+`);
+    if (jsonPath) process__default.default.stderr.write(`[onyx-gen] wrote ${jsonPath}
+`);
+  }
+  return { typesPath, jsonPath };
+}
+
+// gen/cli/generate.ts
+function isTypesFilePath(p) {
+  if (!p) return false;
+  return p.endsWith(".ts") || p.endsWith(".mts") || p.endsWith(".cts") || p.endsWith(".d.ts") || p.endsWith(".d.mts") || p.endsWith(".d.cts");
+}
+function parseArgs(argv) {
+  const opts = {};
+  const next = (i) => argv[i + 1];
+  for (let i = 2; i < argv.length; i++) {
+    const a = argv[i];
+    switch (a) {
+      case "--out":
+      case "--outDir": {
+        const val = next(i);
+        if (!val) throw new Error(`Missing value for ${a}`);
+        if (isTypesFilePath(val)) opts.typesOutFile = val;
+        else opts.typesOutDir = val;
+        i++;
+        break;
+      }
+      case "--types-out":
+      case "--typesOut": {
+        const val = next(i);
+        if (!val) throw new Error(`Missing value for ${a}`);
+        if (isTypesFilePath(val)) opts.typesOutFile = val;
+        else opts.typesOutDir = val;
+        i++;
+        break;
+      }
+      case "--types-file":
+      case "--typesFile": {
+        const val = next(i);
+        if (!val) throw new Error(`Missing value for ${a}`);
+        opts.typesOutFile = val;
+        i++;
+        break;
+      }
+      case "--json-out":
+      case "--jsonOut":
+        opts.jsonOutDir = next(i);
+        i++;
+        break;
+      case "--base":
+      case "--baseName":
+        opts.outBaseName = next(i);
+        i++;
+        break;
+      case "--schema":
+        opts.schemaPath = next(i);
+        i++;
+        break;
+      case "--source": {
+        const v = (next(i) ?? "").toLowerCase();
+        if (v === "api" || v === "file" || v === "auto") opts.source = v;
+        else throw new Error(`Invalid --source: ${v}`);
+        i++;
+        break;
+      }
+      case "--timestamps": {
+        const v = (next(i) ?? "").toLowerCase();
+        if (v === "string" || v === "date" || v === "number") opts.timestampMode = v;
+        else throw new Error(`Invalid --timestamps: ${v}`);
+        i++;
+        break;
+      }
+      case "--name":
+      case "--schemaTypeName":
+        opts.schemaTypeName = next(i);
+        i++;
+        break;
+      case "--prefix":
+        opts.prefix = next(i);
+        i++;
+        break;
+      case "--optional": {
+        const v = (next(i) ?? "").toLowerCase();
+        if (v === "non-null" || v === "nonnull" || v === "nonull") {
+          opts.optional = "non-null";
+        } else if (v === "nullable") {
+          opts.optional = "nullable";
+        } else if (v === "none") {
+          opts.optional = "none";
+        } else {
+          throw new Error(`Invalid --optional: ${v} (use non-null|nullable|none)`);
+        }
+        i++;
+        break;
+      }
+      case "--emit-json":
+        opts.emitJson = true;
+        break;
+      case "--no-emit-json":
+        opts.emitJson = false;
+        break;
+      case "--api-path": {
+        const v = next(i);
+        if (!v || !v.startsWith("/")) throw new Error(`--api-path must start with "/": ${v}`);
+        if (!opts.apiPaths) opts.apiPaths = [];
+        opts.apiPaths.push(v);
+        i++;
+        break;
+      }
+      case "--overwrite":
+        opts.overwrite = true;
+        break;
+      case "--no-overwrite":
+        opts.overwrite = false;
+        break;
+      case "-q":
+      case "--quiet":
+        opts.quiet = true;
+        break;
+      case "-h":
+      case "--help":
+        printHelp();
+        process__default.default.exit(0);
+        break;
+      default:
+        if (a.startsWith("-")) throw new Error(`Unknown option: ${a}`);
+        break;
+    }
+  }
+  return opts;
+}
+function printHelp() {
+  process__default.default.stdout.write(`onyx-gen \u2014 Generate Onyx schema TypeScript types
+
+Usage:
+  onyx-gen [options]
+
+Output selection:
+  --out <path>                     If <path> ends with ".ts", writes exactly to that file.
+                                   Otherwise treats <path> as a directory.
+  --types-out <dir|file>           Same as --out (file-or-dir).
+  --types-file <file.ts>           Explicit file output.
+  --base, --baseName <name>        Base filename (without ext) when writing to a directory (default: onyx.schema)
+  --json-out <dir>                 JSON output directory (used only with --emit-json)
+
+Source selection:
+  --source <auto|api|file>         Where to get schema (default: auto)
+  --schema <path>                  Path to schema JSON when --source=file (or to force local)
+
+Type emission:
+  --timestamps <string|date|number>  Timestamp representation in types (default: date)
+  --name, --schemaTypeName <T>       Exported schema type name (default: OnyxSchema)
+  --prefix <Prefix>                  Prefix to prepend to generated model names (default: none)
+  --optional <non-null|nullable|none>
+                                     Where to add '?' optional props (default: non-null)
+
+Other:
+  --emit-json / --no-emit-json     Emit schema JSON copy (default: no-emit-json)
+  --api-path <path>                Candidate API path to fetch schema; can be repeated
+  --overwrite / --no-overwrite     Overwrite existing files (default: overwrite)
+  -q, --quiet                      Suppress logs
+  -h, --help                       Show this help
+
+Notes:
+  \u2022 Env/config for --source=api uses the same resolver as onyx.init()
+    (env vars, ./onyx-database.json, ~/.onyx/onyx-database-<id>.json, etc.).
+`);
+}
+(async () => {
+  try {
+    const opts = parseArgs(process__default.default.argv);
+    await generateTypes(opts);
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    process__default.default.stderr.write(`onyx-gen: ${msg}
+`);
+    process__default.default.exit(1);
+  }
+})();
+//# sourceMappingURL=generate.cjs.map
+//# sourceMappingURL=generate.cjs.map