@onyx.dev/onyx-database 0.2.0 → 0.3.0

package/dist/gen/cli/generate.cjs

@@ -255,6 +255,97 @@ function mask(obj) {
   return clone;
 }
 
+// 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");
+}
+
 // src/errors/http-error.ts
 var OnyxHttpError = class extends Error {
   name = "OnyxHttpError";
@@ -349,7 +440,8 @@ var HttpClient = class {
       ...method === "DELETE" ? { Prefer: "return=representation" } : {},
       ...extraHeaders ?? {}
     });
-    if (body == null) delete headers["Content-Type"];
+    const hasExplicitContentType = extraHeaders && "Content-Type" in extraHeaders || Object.prototype.hasOwnProperty.call(this.defaults, "Content-Type");
+    if (body == null && !hasExplicitContentType) delete headers["Content-Type"];
     if (this.requestLoggingEnabled) {
       console.log(`${method} ${url}`);
       if (body != null) {
@@ -404,100 +496,1165 @@ var HttpClient = class {
   }
 };
 
-// gen/emit.ts
-var DEFAULTS = {
-  schemaTypeName: "OnyxSchema",
-  timestampMode: "date",
-  modelNamePrefix: "",
-  optionalStrategy: "non-null"
+// src/core/stream.ts
+var debug = (...args) => {
+  if (globalThis.process?.env?.ONYX_STREAM_DEBUG == "true")
+    console.log("[onyx-stream]", ...args);
 };
-function isValidIdentifier(name) {
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(name);
+async function openJsonLinesStream(fetchImpl, url, init = {}, handlers = {}) {
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let canceled = false;
+  let currentReader = null;
+  let retryCount = 0;
+  const maxRetries = 4;
+  const processLine = (line) => {
+    const trimmed = line.trim();
+    debug("line", trimmed);
+    if (!trimmed || trimmed.startsWith(":")) return;
+    const jsonLine = trimmed.startsWith("data:") ? trimmed.slice(5).trim() : trimmed;
+    let obj;
+    try {
+      obj = parseJsonAllowNaN(jsonLine);
+    } catch {
+      return;
+    }
+    const rawAction = obj.action ?? obj.event ?? obj.type ?? obj.eventType ?? obj.changeType;
+    const entity = obj.entity;
+    const action = rawAction?.toUpperCase();
+    if (action === "CREATE" || action === "CREATED" || action === "ADDED" || action === "ADD" || action === "INSERT" || action === "INSERTED")
+      handlers.onItemAdded?.(entity);
+    else if (action === "UPDATE" || action === "UPDATED")
+      handlers.onItemUpdated?.(entity);
+    else if (action === "DELETE" || action === "DELETED" || action === "REMOVE" || action === "REMOVED")
+      handlers.onItemDeleted?.(entity);
+    const canonical = action === "ADDED" || action === "ADD" || action === "CREATE" || action === "CREATED" || action === "INSERT" || action === "INSERTED" ? "CREATE" : action === "UPDATED" || action === "UPDATE" ? "UPDATE" : action === "DELETED" || action === "DELETE" || action === "REMOVE" || action === "REMOVED" ? "DELETE" : action;
+    if (canonical && canonical !== "KEEP_ALIVE")
+      handlers.onItem?.(entity ?? null, canonical);
+    debug("dispatch", canonical, entity);
+  };
+  const connect = async () => {
+    if (canceled) return;
+    debug("connecting", url);
+    try {
+      const res = await fetchImpl(url, {
+        method: init.method ?? "PUT",
+        headers: init.headers ?? {},
+        body: init.body
+      });
+      debug("response", res.status, res.statusText);
+      if (!res.ok) {
+        const raw = await res.text();
+        let parsed = raw;
+        try {
+          parsed = parseJsonAllowNaN(raw);
+        } catch {
+        }
+        debug("non-ok", res.status);
+        throw new OnyxHttpError(`${res.status} ${res.statusText}`, res.status, res.statusText, parsed, raw);
+      }
+      const body = res.body;
+      if (!body || typeof body.getReader !== "function") {
+        debug("no reader");
+        return;
+      }
+      currentReader = body.getReader();
+      debug("connected");
+      retryCount = 0;
+      pump();
+    } catch (err) {
+      debug("connect error", err);
+      if (canceled) return;
+      if (retryCount >= maxRetries) return;
+      const delay = Math.min(1e3 * 2 ** retryCount, 3e4);
+      retryCount++;
+      await new Promise((resolve) => setTimeout(resolve, delay));
+      void connect();
+    }
+  };
+  const pump = () => {
+    if (canceled || !currentReader) return;
+    currentReader.read().then(({ done, value }) => {
+      if (canceled) return;
+      debug("chunk", { done, length: value?.length ?? 0 });
+      if (done) {
+        debug("done");
+        void connect();
+        return;
+      }
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) processLine(line);
+      pump();
+    }).catch((err) => {
+      debug("pump error", err);
+      if (!canceled) void connect();
+    });
+  };
+  await connect();
+  return {
+    cancel() {
+      if (canceled) return;
+      canceled = true;
+      try {
+        currentReader?.cancel();
+      } catch {
+      }
+    }
+  };
 }
-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;
+
+// src/builders/query-results.ts
+var QueryResults = class extends Array {
+  /** Token for the next page of results or null. */
+  nextPage;
+  fetcher;
+  /**
+    * @param records - Records in the current page.
+    * @param nextPage - Token representing the next page.
+    * @param fetcher - Function used to fetch the next page when needed.
+    * @example
+    * ```ts
+    * const results = new QueryResults(users, token, t => fetchMore(t));
+    * ```
+    */
+  constructor(records, nextPage, fetcher) {
+    const items = (() => {
+      if (records == null) return [];
+      if (Array.isArray(records)) return records;
+      if (typeof records[Symbol.iterator] === "function") {
+        return Array.from(records);
+      }
+      if (typeof records.length === "number") {
+        return Array.from(records);
+      }
+      return [records];
+    })();
+    super(...items);
+    Object.setPrototypeOf(this, new.target.prototype);
+    this.nextPage = nextPage;
+    this.fetcher = fetcher;
+  }
+  /**
+   * Returns the first record in the result set.
+   * @throws Error if the result set is empty.
+   * @example
+   * ```ts
+   * const user = results.first();
+   * ```
+   */
+  first() {
+    if (this.length === 0) throw new Error("QueryResults is empty");
+    return this[0];
+  }
+  /**
+   * Returns the first record or `null` if the result set is empty.
+   * @example
+   * ```ts
+   * const user = results.firstOrNull();
+   * ```
+   */
+  firstOrNull() {
+    return this.length > 0 ? this[0] : null;
+  }
+  /**
+   * Checks whether the current page has no records.
+   * @example
+   * ```ts
+   * if (results.isEmpty()) console.log('no data');
+   * ```
+   */
+  isEmpty() {
+    return this.length === 0;
+  }
+  /**
+   * Number of records on the current page.
+   * @example
+   * ```ts
+   * console.log(results.size());
+   * ```
+   */
+  size() {
+    return this.length;
+  }
+  /**
+   * Iterates over each record on the current page only.
+   * @param action - Function to invoke for each record.
+   * @param thisArg - Optional `this` binding for the callback.
+   * @example
+   * ```ts
+   * results.forEachOnPage(u => console.log(u.id));
+   * ```
+   */
+  forEachOnPage(action, thisArg) {
+    super.forEach((value, index) => {
+      action.call(thisArg, value, index, this);
+    });
+  }
+  /**
+   * Iterates over every record across all pages sequentially.
+   * @param action - Function executed for each record. Returning `false`
+   *                 stops iteration early.
+   * @param thisArg - Optional `this` binding for the callback.
+   * @example
+   * ```ts
+   * await results.forEach(u => {
+   *   console.log(u.id);
+   * });
+   * ```
+   */
+  forEach(action, thisArg) {
+    let index = 0;
+    return this.forEachAll(async (item) => {
+      const result = await action.call(thisArg, item, index, this);
+      index += 1;
+      return result;
+    });
+  }
+  /**
+   * Iterates over every record across all pages sequentially.
+   * @param action - Function executed for each record. Returning `false`
+   *                 stops iteration early.
+   * @example
+   * ```ts
+   * await results.forEachAll(u => {
+   *   if (u.disabled) return false;
+   * });
+   * ```
+   */
+  async forEachAll(action) {
+    await this.forEachPage(async (records) => {
+      for (const r of records) {
+        const res = await action(r);
+        if (res === false) return false;
+      }
+      return true;
+    });
+  }
+  /**
+   * Iterates page by page across the result set.
+   * @param action - Function invoked with each page of records. Returning
+   *                 `false` stops iteration.
+   * @example
+   * ```ts
+   * await results.forEachPage(page => {
+   *   console.log(page.length);
+   * });
+   * ```
+   */
+  async forEachPage(action) {
+    let page = this;
+    while (page) {
+      const cont = await action(Array.from(page));
+      if (cont === false) return;
+      if (page.nextPage && page.fetcher) {
+        page = await page.fetcher(page.nextPage);
+      } else {
+        page = null;
+      }
+    }
+  }
+  /**
+   * Collects all records from every page into a single array.
+   * @returns All records.
+   * @example
+   * ```ts
+   * const allUsers = await results.getAllRecords();
+   * ```
+   */
+  async getAllRecords() {
+    const all = [];
+    await this.forEachPage((records) => {
+      all.push(...records);
+    });
+    return all;
+  }
+  /**
+   * Filters all records using the provided predicate.
+   * @param predicate - Function used to test each record.
+   * @example
+   * ```ts
+   * const enabled = await results.filterAll(u => u.enabled);
+   * ```
+   */
+  async filterAll(predicate) {
+    const all = await this.getAllRecords();
+    return all.filter(predicate);
+  }
+  /**
+   * Maps all records using the provided transform.
+   * @param transform - Mapping function.
+   * @example
+   * ```ts
+   * const names = await results.mapAll(u => u.name);
+   * ```
+   */
+  async mapAll(transform) {
+    const all = await this.getAllRecords();
+    return all.map(transform);
+  }
+  /**
+   * Extracts values for a field across all records.
+   * @param field - Name of the field to pluck.
+   * @example
+   * ```ts
+   * const ids = await results.values('id');
+   * ```
+   */
+  // @ts-expect-error overriding Array#values
+  async values(field) {
+    const all = await this.getAllRecords();
+    return all.map((r) => r[field]);
+  }
+  /**
+   * Maximum value produced by the selector across all records.
+   * @param selector - Function extracting a numeric value.
+   * @example
+   * ```ts
+   * const maxAge = await results.maxOfDouble(u => u.age);
+   * ```
+   */
+  async maxOfDouble(selector) {
+    const all = await this.getAllRecords();
+    return all.reduce((max, r) => Math.max(max, selector(r)), -Infinity);
+  }
+  /**
+   * Minimum value produced by the selector across all records.
+   * @param selector - Function extracting a numeric value.
+   * @example
+   * ```ts
+   * const minAge = await results.minOfDouble(u => u.age);
+   * ```
+   */
+  async minOfDouble(selector) {
+    const all = await this.getAllRecords();
+    return all.reduce((min, r) => Math.min(min, selector(r)), Infinity);
+  }
+  /**
+   * Sum of values produced by the selector across all records.
+   * @param selector - Function extracting a numeric value.
+   * @example
+   * ```ts
+   * const total = await results.sumOfDouble(u => u.score);
+   * ```
+   */
+  async sumOfDouble(selector) {
+    const all = await this.getAllRecords();
+    return all.reduce((sum, r) => sum + selector(r), 0);
+  }
+  /**
+   * Maximum float value from the selector.
+   * @param selector - Function extracting a numeric value.
+   */
+  async maxOfFloat(selector) {
+    return this.maxOfDouble(selector);
+  }
+  /**
+   * Minimum float value from the selector.
+   * @param selector - Function extracting a numeric value.
+   */
+  async minOfFloat(selector) {
+    return this.minOfDouble(selector);
+  }
+  /**
+   * Sum of float values from the selector.
+   * @param selector - Function extracting a numeric value.
+   */
+  async sumOfFloat(selector) {
+    return this.sumOfDouble(selector);
+  }
+  /**
+   * Maximum integer value from the selector.
+   * @param selector - Function extracting a numeric value.
+   */
+  async maxOfInt(selector) {
+    return this.maxOfDouble(selector);
+  }
+  /**
+   * Minimum integer value from the selector.
+   * @param selector - Function extracting a numeric value.
+   */
+  async minOfInt(selector) {
+    return this.minOfDouble(selector);
+  }
+  /**
+   * Sum of integer values from the selector.
+   * @param selector - Function extracting a numeric value.
+   */
+  async sumOfInt(selector) {
+    return this.sumOfDouble(selector);
+  }
+  /**
+   * Maximum long value from the selector.
+   * @param selector - Function extracting a numeric value.
+   */
+  async maxOfLong(selector) {
+    return this.maxOfDouble(selector);
+  }
+  /**
+   * Minimum long value from the selector.
+   * @param selector - Function extracting a numeric value.
+   */
+  async minOfLong(selector) {
+    return this.minOfDouble(selector);
+  }
+  /**
+   * Sum of long values from the selector.
+   * @param selector - Function extracting a numeric value.
+   */
+  async sumOfLong(selector) {
+    return this.sumOfDouble(selector);
+  }
+  /**
+   * Sum of bigint values from the selector.
+   * @param selector - Function extracting a bigint value.
+   * @example
+   * ```ts
+   * const total = await results.sumOfBigInt(u => u.balance);
+   * ```
+   */
+  async sumOfBigInt(selector) {
+    const all = await this.getAllRecords();
+    return all.reduce((sum, r) => sum + selector(r), 0n);
+  }
+  /**
+   * Executes an action for each page in parallel.
+   * @param action - Function executed for each record concurrently.
+   * @example
+   * ```ts
+   * await results.forEachPageParallel(async u => sendEmail(u));
+   * ```
+   */
+  async forEachPageParallel(action) {
+    await this.forEachPage((records) => Promise.all(records.map(action)).then(() => true));
+  }
+};
+
+// src/builders/cascade-relationship-builder.ts
+var CascadeRelationshipBuilder = class {
+  graphName;
+  typeName;
+  target;
+  /**
+   * Set the graph name component.
+   *
+   * @param name Graph name or namespace.
+   * @example
+   * ```ts
+   * builder.graph('programs');
+   * ```
+   */
+  graph(name) {
+    this.graphName = name;
+    return this;
+  }
+  /**
+   * Set the graph type component.
+   *
+   * @param type Graph type to target.
+   * @example
+   * ```ts
+   * builder.graphType('StreamingProgram');
+   * ```
+   */
+  graphType(type) {
+    this.typeName = type;
+    return this;
+  }
+  /**
+   * Set the target field for the relationship.
+   *
+   * @param field Target field name.
+   * @example
+   * ```ts
+   * builder.targetField('channelId');
+   * ```
+   */
+  targetField(field) {
+    this.target = field;
+    return this;
+  }
+  /**
+   * Produce the cascade relationship string using the provided source field.
+   *
+   * @param field Source field name.
+   * @example
+   * ```ts
+   * const rel = builder
+   *   .graph('programs')
+   *   .graphType('StreamingProgram')
+   *   .targetField('channelId')
+   *   .sourceField('id');
+   * // rel === 'programs:StreamingProgram(channelId, id)'
+   * ```
+   */
+  sourceField(field) {
+    if (!this.graphName || !this.typeName || !this.target) {
+      throw new Error("Cascade relationship requires graph, type, target, and source fields");
+    }
+    return `${this.graphName}:${this.typeName}(${this.target}, ${field})`;
+  }
+};
+
+// src/errors/onyx-error.ts
+var OnyxError = class extends Error {
+  name = "OnyxError";
+  constructor(message) {
+    super(message);
+  }
+};
+
+// src/impl/onyx.ts
+var DEFAULT_CACHE_TTL = 5 * 60 * 1e3;
+var cachedCfg = null;
+function resolveConfigWithCache(config) {
+  const ttl = config?.ttl ?? DEFAULT_CACHE_TTL;
+  const now = Date.now();
+  if (cachedCfg && cachedCfg.expires > now) {
+    return cachedCfg.promise;
+  }
+  const { ttl: _ttl, requestLoggingEnabled: _reqLog, responseLoggingEnabled: _resLog, ...rest } = config ?? {};
+  const promise = resolveConfig(rest);
+  cachedCfg = { promise, expires: now + ttl };
+  return promise;
 }
-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 clearCacheConfig() {
+  cachedCfg = null;
+}
+function toSingleCondition(criteria) {
+  return { conditionType: "SingleCondition", criteria };
+}
+function flattenStrings(values) {
+  const flat = [];
+  for (const value of values) {
+    if (Array.isArray(value)) {
+      flat.push(...value);
+    } else if (typeof value === "string") {
+      flat.push(value);
+    }
   }
+  return flat;
 }
-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 toCondition(input) {
+  if (typeof input.toCondition === "function") {
+    return input.toCondition();
+  }
+  const c = input;
+  if (c && typeof c.field === "string" && typeof c.operator === "string") {
+    return toSingleCondition(c);
+  }
+  throw new Error("Invalid condition passed to builder.");
 }
-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++}`;
+function serializeDates(value) {
+  if (value instanceof Date) return value.toISOString();
+  if (Array.isArray(value)) return value.map(serializeDates);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      out[k] = serializeDates(v);
     }
-    usedEnumKeys.add(key);
-    return key;
+    return out;
+  }
+  return value;
+}
+function normalizeSecretMetadata(input) {
+  return { ...input, updatedAt: new Date(input.updatedAt) };
+}
+function normalizeSecretRecord(input) {
+  return { ...input, updatedAt: new Date(input.updatedAt) };
+}
+function normalizeDate(value) {
+  if (value == null) return void 0;
+  if (value instanceof Date) return value;
+  const ts = new Date(value);
+  return Number.isNaN(ts.getTime()) ? void 0 : ts;
+}
+function normalizeSchemaRevision(input, fallbackDatabaseId) {
+  const { meta, createdAt, publishedAt, revisionId, ...rest } = input;
+  const mergedMeta = {
+    revisionId: meta?.revisionId ?? revisionId,
+    createdAt: normalizeDate(meta?.createdAt ?? createdAt),
+    publishedAt: normalizeDate(meta?.publishedAt ?? publishedAt)
   };
-  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));
+  const cleanedMeta = mergedMeta.revisionId || mergedMeta.createdAt || mergedMeta.publishedAt ? mergedMeta : void 0;
+  return {
+    ...rest,
+    databaseId: input.databaseId ?? fallbackDatabaseId,
+    meta: cleanedMeta,
+    entities: input.entities ?? []
+  };
+}
+var OnyxDatabaseImpl = class {
+  cfgPromise;
+  resolved = null;
+  http = null;
+  streams = /* @__PURE__ */ new Set();
+  requestLoggingEnabled;
+  responseLoggingEnabled;
+  defaultPartition;
+  constructor(config) {
+    this.requestLoggingEnabled = !!config?.requestLoggingEnabled;
+    this.responseLoggingEnabled = !!config?.responseLoggingEnabled;
+    this.defaultPartition = config?.partition;
+    this.cfgPromise = resolveConfigWithCache(config);
+  }
+  async ensureClient() {
+    if (!this.resolved) {
+      this.resolved = await this.cfgPromise;
     }
-    lines.push("  [key: string]: any;");
-    lines.push("}");
-    lines.push("");
+    if (!this.http) {
+      this.http = new HttpClient({
+        baseUrl: this.resolved.baseUrl,
+        apiKey: this.resolved.apiKey,
+        apiSecret: this.resolved.apiSecret,
+        fetchImpl: this.resolved.fetch,
+        requestLoggingEnabled: this.requestLoggingEnabled,
+        responseLoggingEnabled: this.responseLoggingEnabled
+      });
+    }
+    return {
+      http: this.http,
+      fetchImpl: this.resolved.fetch,
+      baseUrl: this.resolved.baseUrl,
+      databaseId: this.resolved.databaseId
+    };
   }
-  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};`);
+  registerStream(handle) {
+    this.streams.add(handle);
+    return {
+      cancel: () => {
+        try {
+          handle.cancel();
+        } finally {
+          this.streams.delete(handle);
+        }
+      }
+    };
   }
-  lines.push("};");
-  lines.push("");
-  if (opts.schemaTypeName !== "Schema") {
-    lines.push(`export type Schema = ${opts.schemaTypeName};`);
+  /** -------- IOnyxDatabase -------- */
+  from(table) {
+    return new QueryBuilderImpl(this, String(table), this.defaultPartition);
   }
-  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},`);
+  select(...fields) {
+    const qb = new QueryBuilderImpl(
+      this,
+      null,
+      this.defaultPartition
+    );
+    qb.select(...fields);
+    return qb;
   }
-  lines.push("}");
-  lines.push("");
-  return lines.join("\n");
-}
+  cascade(...relationships) {
+    const cb = new CascadeBuilderImpl(this);
+    return cb.cascade(...relationships);
+  }
+  cascadeBuilder() {
+    return new CascadeRelationshipBuilder();
+  }
+  // Impl
+  save(table, entityOrEntities, options) {
+    if (arguments.length === 1) {
+      return new SaveBuilderImpl(this, table);
+    }
+    return this._saveInternal(table, entityOrEntities, options);
+  }
+  async batchSave(table, entities, batchSize = 1e3, options) {
+    for (let i = 0; i < entities.length; i += batchSize) {
+      const chunk = entities.slice(i, i + batchSize);
+      if (chunk.length) {
+        await this._saveInternal(String(table), chunk, options);
+      }
+    }
+  }
+  async findById(table, primaryKey, options) {
+    const { http, databaseId } = await this.ensureClient();
+    const params = new URLSearchParams();
+    const partition = options?.partition ?? this.defaultPartition;
+    if (partition) params.append("partition", partition);
+    if (options?.resolvers?.length) params.append("resolvers", options.resolvers.join(","));
+    const path = `/data/${encodeURIComponent(databaseId)}/${encodeURIComponent(
+      String(table)
+    )}/${encodeURIComponent(primaryKey)}${params.toString() ? `?${params.toString()}` : ""}`;
+    try {
+      return await http.request("GET", path);
+    } catch (err) {
+      if (err instanceof OnyxHttpError && err.status === 404) return null;
+      throw err;
+    }
+  }
+  async delete(table, primaryKey, options) {
+    const { http, databaseId } = await this.ensureClient();
+    const params = new URLSearchParams();
+    const partition = options?.partition ?? this.defaultPartition;
+    if (partition) params.append("partition", partition);
+    if (options?.relationships?.length) {
+      params.append("relationships", options.relationships.map(encodeURIComponent).join(","));
+    }
+    const path = `/data/${encodeURIComponent(databaseId)}/${encodeURIComponent(
+      table
+    )}/${encodeURIComponent(primaryKey)}${params.toString() ? `?${params.toString()}` : ""}`;
+    return http.request("DELETE", path);
+  }
+  async saveDocument(doc) {
+    const { http, databaseId } = await this.ensureClient();
+    const path = `/data/${encodeURIComponent(databaseId)}/document`;
+    return http.request("PUT", path, serializeDates(doc));
+  }
+  async getDocument(documentId, options) {
+    const { http, databaseId } = await this.ensureClient();
+    const params = new URLSearchParams();
+    if (options?.width != null) params.append("width", String(options.width));
+    if (options?.height != null) params.append("height", String(options.height));
+    const path = `/data/${encodeURIComponent(databaseId)}/document/${encodeURIComponent(
+      documentId
+    )}${params.toString() ? `?${params.toString()}` : ""}`;
+    return http.request("GET", path);
+  }
+  async deleteDocument(documentId) {
+    const { http, databaseId } = await this.ensureClient();
+    const path = `/data/${encodeURIComponent(databaseId)}/document/${encodeURIComponent(
+      documentId
+    )}`;
+    return http.request("DELETE", path);
+  }
+  async getSchema(options) {
+    const { http, databaseId } = await this.ensureClient();
+    const params = new URLSearchParams();
+    const tables = options?.tables;
+    const tableList = Array.isArray(tables) ? tables : typeof tables === "string" ? tables.split(",") : [];
+    const normalizedTables = tableList.map((t) => t.trim()).filter(Boolean);
+    if (normalizedTables.length) {
+      params.append("tables", normalizedTables.map(encodeURIComponent).join(","));
+    }
+    const path = `/schemas/${encodeURIComponent(databaseId)}${params.size ? `?${params.toString()}` : ""}`;
+    const res = await http.request("GET", path);
+    return normalizeSchemaRevision(res, databaseId);
+  }
+  async getSchemaHistory() {
+    const { http, databaseId } = await this.ensureClient();
+    const path = `/schemas/history/${encodeURIComponent(databaseId)}`;
+    const res = await http.request("GET", path);
+    return Array.isArray(res) ? res.map((entry) => normalizeSchemaRevision(entry, databaseId)) : [];
+  }
+  async updateSchema(schema, options) {
+    const { http, databaseId } = await this.ensureClient();
+    const params = new URLSearchParams();
+    if (options?.publish) params.append("publish", "true");
+    const path = `/schemas/${encodeURIComponent(databaseId)}${params.size ? `?${params.toString()}` : ""}`;
+    const body = { ...schema, databaseId: schema.databaseId ?? databaseId };
+    const res = await http.request("PUT", path, serializeDates(body));
+    return normalizeSchemaRevision(res, databaseId);
+  }
+  async validateSchema(schema) {
+    const { http, databaseId } = await this.ensureClient();
+    const path = `/schemas/${encodeURIComponent(databaseId)}/validate`;
+    const body = { ...schema, databaseId: schema.databaseId ?? databaseId };
+    const res = await http.request("POST", path, serializeDates(body));
+    const normalizedSchema = res.schema ? normalizeSchemaRevision(res.schema, databaseId) : void 0;
+    return {
+      ...res,
+      valid: res.valid ?? true,
+      schema: normalizedSchema
+    };
+  }
+  async listSecrets() {
+    const { http, databaseId } = await this.ensureClient();
+    const path = `/database/${encodeURIComponent(databaseId)}/secret`;
+    const response = await http.request(
+      "GET",
+      path,
+      void 0,
+      { "Content-Type": "application/json" }
+    );
+    const records = (response.records ?? []).map(normalizeSecretMetadata);
+    return {
+      ...response,
+      records,
+      meta: response.meta ?? { totalRecords: records.length }
+    };
+  }
+  async getSecret(key) {
+    const { http, databaseId } = await this.ensureClient();
+    const path = `/database/${encodeURIComponent(databaseId)}/secret/${encodeURIComponent(key)}`;
+    const record = await http.request("GET", path, void 0, {
+      "Content-Type": "application/json"
+    });
+    return normalizeSecretRecord(record);
+  }
+  async putSecret(key, input) {
+    const { http, databaseId } = await this.ensureClient();
+    const path = `/database/${encodeURIComponent(databaseId)}/secret/${encodeURIComponent(key)}`;
+    const response = await http.request("PUT", path, serializeDates(input));
+    return normalizeSecretMetadata(response);
+  }
+  async deleteSecret(key) {
+    const { http, databaseId } = await this.ensureClient();
+    const path = `/database/${encodeURIComponent(databaseId)}/secret/${encodeURIComponent(key)}`;
+    const response = await http.request(
+      "DELETE",
+      path
+    );
+    const deletedKey = response && typeof response === "object" && "key" in response ? response.key : void 0;
+    return { key: deletedKey ?? key };
+  }
+  close() {
+    for (const h of Array.from(this.streams)) {
+      try {
+        h.cancel();
+      } catch {
+      } finally {
+        this.streams.delete(h);
+      }
+    }
+  }
+  /** -------- internal helpers used by builders -------- */
+  async _count(table, select, partition) {
+    const { http, databaseId } = await this.ensureClient();
+    const params = new URLSearchParams();
+    const p = partition ?? this.defaultPartition;
+    if (p) params.append("partition", p);
+    const path = `/data/${encodeURIComponent(databaseId)}/query/count/${encodeURIComponent(
+      table
+    )}${params.toString() ? `?${params.toString()}` : ""}`;
+    return http.request("PUT", path, serializeDates(select));
+  }
+  async _queryPage(table, select, opts = {}) {
+    const { http, databaseId } = await this.ensureClient();
+    const params = new URLSearchParams();
+    if (opts.pageSize != null) params.append("pageSize", String(opts.pageSize));
+    if (opts.nextPage) params.append("nextPage", opts.nextPage);
+    const p = opts.partition ?? this.defaultPartition;
+    if (p) params.append("partition", p);
+    const path = `/data/${encodeURIComponent(databaseId)}/query/${encodeURIComponent(
+      table
+    )}${params.toString() ? `?${params.toString()}` : ""}`;
+    return http.request("PUT", path, serializeDates(select));
+  }
+  async _update(table, update, partition) {
+    const { http, databaseId } = await this.ensureClient();
+    const params = new URLSearchParams();
+    const p = partition ?? this.defaultPartition;
+    if (p) params.append("partition", p);
+    const path = `/data/${encodeURIComponent(databaseId)}/query/update/${encodeURIComponent(
+      table
+    )}${params.toString() ? `?${params.toString()}` : ""}`;
+    return http.request("PUT", path, serializeDates(update));
+  }
+  async _deleteByQuery(table, select, partition) {
+    const { http, databaseId } = await this.ensureClient();
+    const params = new URLSearchParams();
+    const p = partition ?? this.defaultPartition;
+    if (p) params.append("partition", p);
+    const path = `/data/${encodeURIComponent(databaseId)}/query/delete/${encodeURIComponent(
+      table
+    )}${params.toString() ? `?${params.toString()}` : ""}`;
+    return http.request("PUT", path, serializeDates(select));
+  }
+  async _stream(table, select, includeQueryResults, keepAlive, handlers) {
+    const { http, baseUrl, databaseId, fetchImpl } = await this.ensureClient();
+    const params = new URLSearchParams();
+    if (includeQueryResults) params.append("includeQueryResults", "true");
+    if (keepAlive) params.append("keepAlive", "true");
+    const url = `${baseUrl}/data/${encodeURIComponent(databaseId)}/query/stream/${encodeURIComponent(
+      table
+    )}${params.toString() ? `?${params.toString()}` : ""}`;
+    const handle = await openJsonLinesStream(
+      fetchImpl,
+      url,
+      {
+        method: "PUT",
+        headers: http.headers({
+          Accept: "application/x-ndjson",
+          "Content-Type": "application/json"
+        }),
+        body: JSON.stringify(serializeDates(select))
+      },
+      handlers
+    );
+    return this.registerStream(handle);
+  }
+  async _saveInternal(table, entityOrEntities, options) {
+    const { http, databaseId } = await this.ensureClient();
+    const params = new URLSearchParams();
+    if (options?.relationships?.length) {
+      params.append("relationships", options.relationships.map(encodeURIComponent).join(","));
+    }
+    const path = `/data/${encodeURIComponent(databaseId)}/${encodeURIComponent(table)}${params.toString() ? `?${params.toString()}` : ""}`;
+    return http.request("PUT", path, serializeDates(entityOrEntities));
+  }
+};
+var QueryBuilderImpl = class {
+  db;
+  table;
+  fields = null;
+  resolvers = null;
+  conditions = null;
+  sort = null;
+  limitValue = null;
+  distinctValue = false;
+  groupByValues = null;
+  partitionValue;
+  pageSizeValue = null;
+  nextPageValue = null;
+  mode = "select";
+  updates = null;
+  onItemAddedListener = null;
+  onItemUpdatedListener = null;
+  onItemDeletedListener = null;
+  onItemListener = null;
+  constructor(db, table, partition) {
+    this.db = db;
+    this.table = table;
+    this.partitionValue = partition;
+  }
+  ensureTable() {
+    if (!this.table) throw new Error("Table is not defined. Call from(<table>) first.");
+    return this.table;
+  }
+  toSelectQuery() {
+    return {
+      type: "SelectQuery",
+      fields: this.fields,
+      conditions: this.conditions,
+      sort: this.sort,
+      limit: this.limitValue,
+      distinct: this.distinctValue,
+      groupBy: this.groupByValues,
+      partition: this.partitionValue ?? null,
+      resolvers: this.resolvers
+    };
+  }
+  from(table) {
+    this.table = table;
+    return this;
+  }
+  select(...fields) {
+    const flat = flattenStrings(fields);
+    this.fields = flat.length > 0 ? flat : null;
+    return this;
+  }
+  resolve(...values) {
+    const flat = flattenStrings(values);
+    this.resolvers = flat.length > 0 ? flat : null;
+    return this;
+  }
+  where(condition) {
+    const c = toCondition(condition);
+    if (!this.conditions) {
+      this.conditions = c;
+    } else {
+      this.conditions = {
+        conditionType: "CompoundCondition",
+        operator: "AND",
+        conditions: [this.conditions, c]
+      };
+    }
+    return this;
+  }
+  and(condition) {
+    const c = toCondition(condition);
+    if (!this.conditions) {
+      this.conditions = c;
+    } else if (this.conditions.conditionType === "CompoundCondition" && this.conditions.operator === "AND") {
+      this.conditions.conditions.push(c);
+    } else {
+      this.conditions = {
+        conditionType: "CompoundCondition",
+        operator: "AND",
+        conditions: [this.conditions, c]
+      };
+    }
+    return this;
+  }
+  or(condition) {
+    const c = toCondition(condition);
+    if (!this.conditions) {
+      this.conditions = c;
+    } else if (this.conditions.conditionType === "CompoundCondition" && this.conditions.operator === "OR") {
+      this.conditions.conditions.push(c);
+    } else {
+      this.conditions = {
+        conditionType: "CompoundCondition",
+        operator: "OR",
+        conditions: [this.conditions, c]
+      };
+    }
+    return this;
+  }
+  orderBy(...sorts) {
+    this.sort = sorts;
+    return this;
+  }
+  groupBy(...fields) {
+    this.groupByValues = fields.length ? fields : null;
+    return this;
+  }
+  distinct() {
+    this.distinctValue = true;
+    return this;
+  }
+  limit(n) {
+    this.limitValue = n;
+    return this;
+  }
+  inPartition(partition) {
+    this.partitionValue = partition;
+    return this;
+  }
+  pageSize(n) {
+    this.pageSizeValue = n;
+    return this;
+  }
+  nextPage(token) {
+    this.nextPageValue = token;
+    return this;
+  }
+  setUpdates(updates) {
+    this.mode = "update";
+    this.updates = updates;
+    return this;
+  }
+  async count() {
+    if (this.mode !== "select") throw new Error("Cannot call count() in update mode.");
+    const table = this.ensureTable();
+    return this.db._count(table, this.toSelectQuery(), this.partitionValue);
+  }
+  async page(options = {}) {
+    if (this.mode !== "select") throw new Error("Cannot call page() in update mode.");
+    const table = this.ensureTable();
+    const final = {
+      pageSize: this.pageSizeValue ?? options.pageSize,
+      nextPage: this.nextPageValue ?? options.nextPage,
+      partition: this.partitionValue
+    };
+    return this.db._queryPage(table, this.toSelectQuery(), final);
+  }
+  list(options = {}) {
+    const size = this.pageSizeValue ?? options.pageSize;
+    const pgPromise = this.page(options).then((pg) => {
+      const fetcher = (token) => this.nextPage(token).list({ pageSize: size });
+      return new QueryResults(Array.isArray(pg.records) ? pg.records : [], pg.nextPage ?? null, fetcher);
+    });
+    for (const m of Object.getOwnPropertyNames(QueryResults.prototype)) {
+      if (m === "constructor") continue;
+      pgPromise[m] = (...args) => pgPromise.then((res) => res[m](...args));
+    }
+    return pgPromise;
+  }
+  async firstOrNull() {
+    if (this.mode !== "select") throw new Error("Cannot call firstOrNull() in update mode.");
+    if (!this.conditions) throw new OnyxError("firstOrNull() requires a where() clause.");
+    this.limitValue = 1;
+    const pg = await this.page();
+    return Array.isArray(pg.records) && pg.records.length > 0 ? pg.records[0] : null;
+  }
+  async one() {
+    return this.firstOrNull();
+  }
+  async delete() {
+    if (this.mode !== "select") throw new Error("delete() is only applicable in select mode.");
+    const table = this.ensureTable();
+    return this.db._deleteByQuery(table, this.toSelectQuery(), this.partitionValue);
+  }
+  async update() {
+    if (this.mode !== "update") throw new Error("Call setUpdates(...) before update().");
+    const table = this.ensureTable();
+    const update = {
+      type: "UpdateQuery",
+      conditions: this.conditions,
+      updates: this.updates ?? {},
+      sort: this.sort,
+      limit: this.limitValue,
+      partition: this.partitionValue ?? null
+    };
+    return this.db._update(table, update, this.partitionValue);
+  }
+  onItemAdded(listener) {
+    this.onItemAddedListener = listener;
+    return this;
+  }
+  onItemUpdated(listener) {
+    this.onItemUpdatedListener = listener;
+    return this;
+  }
+  onItemDeleted(listener) {
+    this.onItemDeletedListener = listener;
+    return this;
+  }
+  onItem(listener) {
+    this.onItemListener = listener;
+    return this;
+  }
+  async streamEventsOnly(keepAlive = true) {
+    return this.stream(false, keepAlive);
+  }
+  async streamWithQueryResults(keepAlive = false) {
+    return this.stream(true, keepAlive);
+  }
+  async stream(includeQueryResults = true, keepAlive = false) {
+    if (this.mode !== "select") throw new Error("Streaming is only applicable in select mode.");
+    const table = this.ensureTable();
+    return this.db._stream(table, this.toSelectQuery(), includeQueryResults, keepAlive, {
+      onItemAdded: this.onItemAddedListener ?? void 0,
+      onItemUpdated: this.onItemUpdatedListener ?? void 0,
+      onItemDeleted: this.onItemDeletedListener ?? void 0,
+      onItem: this.onItemListener ?? void 0
+    });
+  }
+};
+var SaveBuilderImpl = class {
+  db;
+  table;
+  relationships = null;
+  constructor(db, table) {
+    this.db = db;
+    this.table = table;
+  }
+  cascade(...relationships) {
+    this.relationships = relationships.flat();
+    return this;
+  }
+  one(entity) {
+    const opts = this.relationships ? { relationships: this.relationships } : void 0;
+    return this.db._saveInternal(this.table, entity, opts);
+  }
+  many(entities) {
+    const opts = this.relationships ? { relationships: this.relationships } : void 0;
+    return this.db._saveInternal(this.table, entities, opts);
+  }
+};
+var CascadeBuilderImpl = class {
+  db;
+  rels = null;
+  constructor(db) {
+    this.db = db;
+  }
+  cascade(...relationships) {
+    this.rels = relationships.flat();
+    return this;
+  }
+  save(table, entityOrEntities) {
+    const opts = this.rels ? { relationships: this.rels } : void 0;
+    return this.db._saveInternal(String(table), entityOrEntities, opts);
+  }
+  delete(table, primaryKey) {
+    const opts = this.rels ? { relationships: this.rels } : void 0;
+    return this.db.delete(table, primaryKey, opts);
+  }
+};
+var onyx = {
+  init(config) {
+    return new OnyxDatabaseImpl(config);
+  },
+  clearCacheConfig
+};
 
 // gen/generate.ts
+var DEFAULT_SCHEMA_PATH = "./onyx.schema.json";
+var DEFAULT_TYPES_OUT = "./onyx/types.ts";
 var DEFAULTS2 = {
-  source: "auto",
+  source: "file",
   outBaseName: "onyx.schema",
   emitJson: false,
   overwrite: true,
@@ -506,6 +1663,14 @@ var DEFAULTS2 = {
   optional: "non-null",
   quiet: false
 };
+function toArray(val) {
+  if (!val) return [];
+  return Array.isArray(val) ? val : [val];
+}
+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");
+}
 async function readFileJson(path) {
   const fs = await import('fs/promises');
   const txt = await fs.readFile(path, "utf8");
@@ -529,108 +1694,162 @@ async function writeFile(path, data, overwrite) {
 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;
-    }
+function normalizeAttributeType(raw) {
+  const t = typeof raw === "string" ? raw : "";
+  switch (t) {
+    case "String":
+      return "String";
+    case "Boolean":
+      return "Boolean";
+    case "Timestamp":
+      return "Timestamp";
+    case "EmbeddedList":
+      return "EmbeddedList";
+    case "EmbeddedObject":
+      return "EmbeddedObject";
+    case "Int":
+    case "Byte":
+    case "Short":
+    case "Float":
+    case "Double":
+    case "Long":
+      return "Int";
+    default:
+      return "EmbeddedObject";
   }
-  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}`
-  );
+}
+function toOnyxIntrospectionFromEntities(entities) {
+  return {
+    tables: entities.map((entity) => ({
+      name: entity.name,
+      attributes: (entity.attributes ?? []).map((attr) => ({
+        name: attr.name,
+        type: normalizeAttributeType(attr.type),
+        isNullable: Boolean(attr.isNullable)
+      }))
+    }))
+  };
+}
+function normalizeIntrospection(raw) {
+  if (isIntrospection(raw)) return raw;
+  const entities = raw.entities;
+  if (Array.isArray(entities)) {
+    return toOnyxIntrospectionFromEntities(entities);
+  }
+  throw new Error('Invalid schema: missing "tables" array.');
+}
+async function fetchSchemaFromApi(config) {
+  const db = onyx.init({
+    baseUrl: config.baseUrl,
+    databaseId: config.databaseId,
+    apiKey: config.apiKey,
+    apiSecret: config.apiSecret,
+    fetch: config.fetch
+  });
+  const schema = await db.getSchema();
+  return normalizeIntrospection(schema);
 }
 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"');
+  const resolvedSchemaPath = opts.schemaPath ?? (opts.source === "file" ? DEFAULT_SCHEMA_PATH : void 0);
+  let schemaInput = null;
+  if (opts.source === "file" || opts.source === "auto" && resolvedSchemaPath) {
+    if (!resolvedSchemaPath) 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}
+      process__default.default.stderr.write(`[onyx-gen] reading schema from file: ${resolvedSchemaPath}
 `);
-    schema = await readFileJson(opts.schemaPath);
+    schemaInput = await readFileJson(resolvedSchemaPath);
   }
-  if (!schema) {
+  if (!schemaInput) {
     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 (!cfg.databaseId) {
+      throw new Error("Missing databaseId. Set ONYX_DATABASE_ID or pass to onyx.init().");
+    }
     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;
+    schemaInput = await fetchSchemaFromApi(cfg);
   }
+  const schema = normalizeIntrospection(schemaInput);
+  const outTargets = [
+    ...toArray(opts.typesOutFile),
+    ...toArray(opts.typesOutDir),
+    ...toArray(opts.outDir)
+  ].map((p) => p.trim()).filter(Boolean);
+  if (outTargets.length === 0) {
+    outTargets.push(DEFAULT_TYPES_OUT);
+  }
+  const outputs = outTargets.map((target) => {
+    const outIsFile = isTypesFilePath(target);
+    const typesPath = outIsFile ? path.resolve(process__default.default.cwd(), target) : path.join(path.resolve(process__default.default.cwd(), target), `${opts.outBaseName}.ts`);
+    const typesDirAbs = outIsFile ? path.dirname(typesPath) : path.resolve(process__default.default.cwd(), target);
+    const jsonBaseName = outIsFile ? path.basename(typesPath, path.extname(typesPath)) : opts.outBaseName;
+    return { typesPath, typesDirAbs, jsonBaseName };
+  });
   const types = emitTypes(schema, {
     schemaTypeName: opts.schemaTypeName,
     timestampMode: opts.timestampMode,
     modelNamePrefix: opts.prefix ?? "",
     optionalStrategy: opts.optional
   });
-  await writeFile(typesPath, `${types}
+  const typesPaths = [];
+  for (const out of outputs) {
+    await ensureDir(out.typesDirAbs);
+    await writeFile(out.typesPath, `${types}
 `, opts.overwrite);
-  let jsonPath;
+    typesPaths.push(out.typesPath);
+  }
+  let jsonPaths;
   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}
+    jsonPaths = [];
+    for (const out of outputs) {
+      const jsonOutDirAbs = path.resolve(process__default.default.cwd(), opts.jsonOutDir ?? out.typesDirAbs);
+      await ensureDir(jsonOutDirAbs);
+      const jsonPath = path.join(jsonOutDirAbs, `${out.jsonBaseName}.json`);
+      await writeFile(jsonPath, `${jsonPretty}
 `, opts.overwrite);
+      jsonPaths.push(jsonPath);
+    }
   }
   if (!opts.quiet) {
-    process__default.default.stderr.write(`[onyx-gen] wrote ${typesPath}
+    for (const p of typesPaths) {
+      process__default.default.stderr.write(`[onyx-gen] wrote ${p}
 `);
-    if (jsonPath) process__default.default.stderr.write(`[onyx-gen] wrote ${jsonPath}
+    }
+    if (jsonPaths) {
+      for (const jp of jsonPaths) {
+        process__default.default.stderr.write(`[onyx-gen] wrote ${jp}
 `);
+      }
+    }
   }
-  return { typesPath, jsonPath };
+  return { typesPath: typesPaths[0], jsonPath: jsonPaths?.[0], typesPaths, jsonPaths };
 }
 
 // gen/cli/generate.ts
-function isTypesFilePath(p) {
+function isTypesFilePath2(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 appendVal(current, val) {
+  if (!current) return val;
+  return Array.isArray(current) ? [...current, val] : [current, val];
+}
+function addOut(opts, raw, forceFile = false) {
+  if (!raw) throw new Error("Missing value for output flag");
+  const parts = raw.split(",").map((p) => p.trim()).filter(Boolean);
+  for (const val of parts) {
+    if (forceFile || isTypesFilePath2(val)) {
+      opts.typesOutFile = appendVal(opts.typesOutFile, val);
+    } else {
+      opts.typesOutDir = appendVal(opts.typesOutDir, val);
+    }
+  }
+  return opts;
+}
 function parseArgs(argv) {
   const opts = {};
   const next = (i) => argv[i + 1];
@@ -639,27 +1858,19 @@ function parseArgs(argv) {
     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;
+        addOut(opts, next(i));
         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;
+        addOut(opts, next(i));
         i++;
         break;
       }
       case "--types-file":
       case "--typesFile": {
-        const val = next(i);
-        if (!val) throw new Error(`Missing value for ${a}`);
-        opts.typesOutFile = val;
+        addOut(opts, next(i), true);
         i++;
         break;
       }
@@ -757,16 +1968,17 @@ 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.
+  --out <path[,path2,...]>         If a value ends with ".ts", writes exactly to that file.
+                                   Otherwise treats it as a directory. Comma-separate or repeat to
+                                   write multiple outputs. Default: ./onyx/types.ts
+  --types-out <dir|file>[,more]    Same as --out (file-or-dir).
+  --types-file <file.ts>[,more]    Explicit file output(s).
   --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)
+  --source <auto|api|file>         Where to get schema (default: file)
+  --schema <path>                  Path to schema JSON when --source=file (default: ./onyx.schema.json)
 
 Type emission:
   --timestamps <string|date|number>  Timestamp representation in types (default: date)
@@ -783,6 +1995,7 @@ Other:
   -h, --help                       Show this help
 
 Notes:
+  \u2022 Running with no flags defaults to: --source file --schema ./onyx.schema.json --out ./onyx/types.ts
   \u2022 Env/config for --source=api uses the same resolver as onyx.init()
     (env vars, ./onyx-database.json, ~/.onyx/onyx-database-<id>.json, etc.).
 `);