@onyx.dev/onyx-database 0.3.0 → 1.0.2

package/dist/schema/cli/schema.cjs

@@ -78,7 +78,7 @@ function readEnv(targetId) {
   return res;
 }
 async function readProjectFile(databaseId) {
-  if (!isNode) return {};
+  if (!isNode) return { config: {} };
   const fs = await nodeImport("node:fs/promises");
   const path2 = await nodeImport("node:path");
   const cwd = gProcess?.cwd?.() ?? ".";
@@ -87,7 +87,7 @@ async function readProjectFile(databaseId) {
     const sanitized = txt.replace(/[\r\n]+/g, "");
     const json = dropUndefined(JSON.parse(sanitized));
     dbg("project file:", p, "\u2192", mask(json));
-    return json;
+    return { config: json, path: p };
   };
   if (databaseId) {
     const specific = path2.resolve(cwd, `onyx-database-${databaseId}.json`);
@@ -102,11 +102,11 @@ async function readProjectFile(databaseId) {
     return await tryRead(fallback);
   } catch {
     dbg("project file not found:", fallback);
-    return {};
+    return { config: {} };
   }
 }
 async function readHomeProfile(databaseId) {
-  if (!isNode) return {};
+  if (!isNode) return { config: {} };
   const fs = await nodeImport("node:fs/promises");
   const os = await nodeImport("node:os");
   const path2 = await nodeImport("node:path");
@@ -126,7 +126,7 @@ async function readHomeProfile(databaseId) {
       const sanitized = txt.replace(/[\r\n]+/g, "");
       const json = dropUndefined(JSON.parse(sanitized));
       dbg("home profile used:", p, "\u2192", mask(json));
-      return json;
+      return { config: json, path: p };
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       throw new OnyxConfigError(`Failed to read ${p}: ${msg}`);
@@ -145,7 +145,7 @@ async function readHomeProfile(databaseId) {
   dbg("no home-root fallback:", defaultInHome);
   if (!await fileExists(dir)) {
     dbg("~/.onyx does not exist:", dir);
-    return {};
+    return { config: {} };
   }
   const files = await fs.readdir(dir).catch(() => []);
   const matches = files.filter((f) => f.startsWith("onyx-database-") && f.endsWith(".json"));
@@ -159,10 +159,10 @@ async function readHomeProfile(databaseId) {
     );
   }
   dbg("no usable home profiles found in", dir);
-  return {};
+  return { config: {} };
 }
 async function readConfigPath(p) {
-  if (!isNode) return {};
+  if (!isNode) return { config: {} };
   const fs = await nodeImport("node:fs/promises");
   const path2 = await nodeImport("node:path");
   const cwd = gProcess?.cwd?.() ?? ".";
@@ -172,7 +172,7 @@ async function readConfigPath(p) {
     const sanitized = txt.replace(/[\r\n]+/g, "");
     const json = dropUndefined(JSON.parse(sanitized));
     dbg("config path:", resolved, "\u2192", mask(json));
-    return json;
+    return { config: json, path: resolved };
   } catch (e) {
     const msg = e instanceof Error ? e.message : String(e);
     throw new OnyxConfigError(`Failed to read ${resolved}: ${msg}`);
@@ -183,7 +183,8 @@ async function resolveConfig(input) {
   const env = readEnv(input?.databaseId);
   let cfgPath = {};
   if (configPath) {
-    cfgPath = await readConfigPath(configPath);
+    const cfgRes = await readConfigPath(configPath);
+    cfgPath = cfgRes.config;
   }
   const targetId = input?.databaseId ?? env.databaseId ?? cfgPath.databaseId;
   let haveDbId = !!(input?.databaseId ?? env.databaseId ?? cfgPath.databaseId);
@@ -191,14 +192,16 @@ async function resolveConfig(input) {
   let haveApiSecret = !!(input?.apiSecret ?? env.apiSecret ?? cfgPath.apiSecret);
   let project = {};
   if (!(haveDbId && haveApiKey && haveApiSecret)) {
-    project = await readProjectFile(targetId);
+    const projRes = await readProjectFile(targetId);
+    project = projRes.config;
     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 homeRes = await readHomeProfile(targetId);
+    home = homeRes.config;
   }
   const merged = {
     baseUrl: DEFAULT_BASE_URL,
@@ -249,6 +252,27 @@ async function resolveConfig(input) {
   dbg("resolved:", mask(resolved));
   return resolved;
 }
+async function resolveConfigWithSource(input) {
+  const configPathEnv = gProcess?.env?.ONYX_CONFIG_PATH;
+  const env = readEnv(input?.databaseId);
+  const cfgPathRes = configPathEnv ? await readConfigPath(configPathEnv) : { config: {} };
+  const cfgPath = cfgPathRes.config;
+  const projectRes = await readProjectFile(env.databaseId ?? cfgPath.databaseId);
+  const project = projectRes.config;
+  const homeRes = await readHomeProfile(env.databaseId ?? cfgPath.databaseId);
+  const home = homeRes.config;
+  const base = await resolveConfig(input);
+  const sources = {
+    baseUrl: input?.baseUrl ? "explicit config" : env.baseUrl ? "env" : cfgPath.baseUrl ? "env ONYX_CONFIG_PATH" : project.baseUrl ? "project file" : home.baseUrl ? "home profile" : "default",
+    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",
+    configPath: cfgPathRes.path,
+    projectFile: projectRes.path,
+    homeProfile: homeRes.path
+  };
+  return { ...base, sources };
+}
 function mask(obj) {
   if (!obj) return obj;
   const clone = { ...obj };
@@ -842,6 +866,56 @@ var QueryResults = class extends Array {
   }
 };
 
+// src/helpers/condition-normalizer.ts
+function isQueryBuilderLike(value) {
+  return !!value && typeof value.toSerializableQueryObject === "function";
+}
+function normalizeCriteriaValue(value) {
+  if (Array.isArray(value)) {
+    let changed = false;
+    const normalized = value.map((item) => {
+      const result = normalizeCriteriaValue(item);
+      if (result.changed) changed = true;
+      return result.value;
+    });
+    if (!changed) {
+      for (let i = 0; i < normalized.length; i += 1) {
+        if (normalized[i] !== value[i]) {
+          changed = true;
+          break;
+        }
+      }
+    }
+    return { value: changed ? normalized : value, changed };
+  }
+  if (isQueryBuilderLike(value)) {
+    return { value: value.toSerializableQueryObject(), changed: true };
+  }
+  return { value, changed: false };
+}
+function normalizeConditionInternal(condition) {
+  if (condition.conditionType === "SingleCondition") {
+    const { value, changed: changed2 } = normalizeCriteriaValue(condition.criteria.value);
+    if (!changed2) return condition;
+    return {
+      ...condition,
+      criteria: { ...condition.criteria, value }
+    };
+  }
+  let changed = false;
+  const normalizedConditions = condition.conditions.map((child) => {
+    const normalized = normalizeConditionInternal(child);
+    if (normalized !== child) changed = true;
+    return normalized;
+  });
+  if (!changed) return condition;
+  return { ...condition, conditions: normalizedConditions };
+}
+function normalizeCondition(condition) {
+  if (!condition) return condition;
+  return normalizeConditionInternal(condition);
+}
+
 // src/builders/cascade-relationship-builder.ts
 var CascadeRelationshipBuilder = class {
   graphName;
@@ -916,6 +990,297 @@ var OnyxError = class extends Error {
   }
 };
 
+// src/helpers/schema-diff.ts
+function mapByName(items) {
+  const map = /* @__PURE__ */ new Map();
+  for (const item of items ?? []) {
+    if (!item?.name) continue;
+    map.set(item.name, item);
+  }
+  return map;
+}
+function normalizeEntities(schema) {
+  if (Array.isArray(schema.entities)) {
+    return schema.entities ?? [];
+  }
+  const tables = schema.tables;
+  if (!Array.isArray(tables)) return [];
+  return tables.map((table) => ({
+    name: table.name,
+    attributes: table.attributes ?? []
+  }));
+}
+function normalizePartition(partition) {
+  if (partition == null) return "";
+  const trimmed = partition.trim();
+  return trimmed;
+}
+function identifiersEqual(a, b) {
+  if (!a && !b) return true;
+  if (!a || !b) return false;
+  return a.name === b.name && a.generator === b.generator && a.type === b.type;
+}
+function diffAttributes(apiAttrs, localAttrs) {
+  const apiMap = mapByName(apiAttrs);
+  const localMap = mapByName(localAttrs);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [name, local] of localMap.entries()) {
+    if (!apiMap.has(name)) {
+      added.push(local);
+      continue;
+    }
+    const api = apiMap.get(name);
+    const apiNull = Boolean(api.isNullable);
+    const localNull = Boolean(local.isNullable);
+    if (api.type !== local.type || apiNull !== localNull) {
+      changed.push({
+        name,
+        from: { type: api.type, isNullable: apiNull },
+        to: { type: local.type, isNullable: localNull }
+      });
+    }
+  }
+  for (const name of apiMap.keys()) {
+    if (!localMap.has(name)) removed.push(name);
+  }
+  added.sort((a, b) => a.name.localeCompare(b.name));
+  removed.sort();
+  changed.sort((a, b) => a.name.localeCompare(b.name));
+  if (!added.length && !removed.length && !changed.length) return null;
+  return { added, removed, changed };
+}
+function diffIndexes(apiIndexes, localIndexes) {
+  const apiMap = mapByName(apiIndexes);
+  const localMap = mapByName(localIndexes);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [name, local] of localMap.entries()) {
+    if (!apiMap.has(name)) {
+      added.push(local);
+      continue;
+    }
+    const api = apiMap.get(name);
+    const apiType = api.type ?? "DEFAULT";
+    const localType = local.type ?? "DEFAULT";
+    const apiScore = api.minimumScore;
+    const localScore = local.minimumScore;
+    if (apiType !== localType || apiScore !== localScore) {
+      changed.push({ name, from: api, to: local });
+    }
+  }
+  for (const name of apiMap.keys()) {
+    if (!localMap.has(name)) removed.push(name);
+  }
+  added.sort((a, b) => a.name.localeCompare(b.name));
+  removed.sort();
+  changed.sort((a, b) => a.name.localeCompare(b.name));
+  if (!added.length && !removed.length && !changed.length) return null;
+  return { added, removed, changed };
+}
+function diffResolvers(apiResolvers, localResolvers) {
+  const apiMap = mapByName(apiResolvers);
+  const localMap = mapByName(localResolvers);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [name, local] of localMap.entries()) {
+    if (!apiMap.has(name)) {
+      added.push(local);
+      continue;
+    }
+    const api = apiMap.get(name);
+    if (api.resolver !== local.resolver) {
+      changed.push({ name, from: api, to: local });
+    }
+  }
+  for (const name of apiMap.keys()) {
+    if (!localMap.has(name)) removed.push(name);
+  }
+  added.sort((a, b) => a.name.localeCompare(b.name));
+  removed.sort();
+  changed.sort((a, b) => a.name.localeCompare(b.name));
+  if (!added.length && !removed.length && !changed.length) return null;
+  return { added, removed, changed };
+}
+function diffTriggers(apiTriggers, localTriggers) {
+  const apiMap = mapByName(apiTriggers);
+  const localMap = mapByName(localTriggers);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [name, local] of localMap.entries()) {
+    if (!apiMap.has(name)) {
+      added.push(local);
+      continue;
+    }
+    const api = apiMap.get(name);
+    if (api.event !== local.event || api.trigger !== local.trigger) {
+      changed.push({ name, from: api, to: local });
+    }
+  }
+  for (const name of apiMap.keys()) {
+    if (!localMap.has(name)) removed.push(name);
+  }
+  added.sort((a, b) => a.name.localeCompare(b.name));
+  removed.sort();
+  changed.sort((a, b) => a.name.localeCompare(b.name));
+  if (!added.length && !removed.length && !changed.length) return null;
+  return { added, removed, changed };
+}
+function computeSchemaDiff(apiSchema, localSchema) {
+  const apiEntities = normalizeEntities(apiSchema);
+  const localEntities = normalizeEntities(localSchema);
+  const apiMap = mapByName(apiEntities);
+  const localMap = mapByName(localEntities);
+  const newTables = [];
+  const removedTables = [];
+  const changedTables = [];
+  for (const [name, localEntity] of localMap.entries()) {
+    if (!apiMap.has(name)) {
+      newTables.push(name);
+      continue;
+    }
+    const apiEntity = apiMap.get(name);
+    const tableDiff = { name };
+    const partitionFrom = normalizePartition(apiEntity.partition);
+    const partitionTo = normalizePartition(localEntity.partition);
+    if (partitionFrom !== partitionTo) {
+      tableDiff.partition = { from: partitionFrom || null, to: partitionTo || null };
+    }
+    if (!identifiersEqual(apiEntity.identifier, localEntity.identifier)) {
+      tableDiff.identifier = {
+        from: apiEntity.identifier ?? null,
+        to: localEntity.identifier ?? null
+      };
+    }
+    const attrs = diffAttributes(apiEntity.attributes, localEntity.attributes);
+    if (attrs) tableDiff.attributes = attrs;
+    const indexes = diffIndexes(apiEntity.indexes, localEntity.indexes);
+    if (indexes) tableDiff.indexes = indexes;
+    const resolvers = diffResolvers(apiEntity.resolvers, localEntity.resolvers);
+    if (resolvers) tableDiff.resolvers = resolvers;
+    const triggers = diffTriggers(apiEntity.triggers, localEntity.triggers);
+    if (triggers) tableDiff.triggers = triggers;
+    const hasChange = tableDiff.partition || tableDiff.identifier || tableDiff.attributes || tableDiff.indexes || tableDiff.resolvers || tableDiff.triggers;
+    if (hasChange) {
+      changedTables.push(tableDiff);
+    }
+  }
+  for (const name of apiMap.keys()) {
+    if (!localMap.has(name)) removedTables.push(name);
+  }
+  newTables.sort();
+  removedTables.sort();
+  changedTables.sort((a, b) => a.name.localeCompare(b.name));
+  return { newTables, removedTables, changedTables };
+}
+function isScalar(value) {
+  return value == null || value instanceof Date || typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+}
+function formatScalar(value) {
+  if (value === null || value === void 0) return "null";
+  if (value instanceof Date) return JSON.stringify(value.toISOString());
+  if (typeof value === "string") return JSON.stringify(value);
+  return String(value);
+}
+function isRecord(value) {
+  return !!value && typeof value === "object" && !Array.isArray(value) && !(value instanceof Date);
+}
+function toYamlLines(value, indent = 0) {
+  const pad = " ".repeat(indent);
+  if (Array.isArray(value)) {
+    if (!value.length) return [`${pad}[]`];
+    const lines = [];
+    for (const item of value) {
+      if (isScalar(item)) {
+        lines.push(`${pad}- ${formatScalar(item)}`);
+        continue;
+      }
+      const nested = toYamlLines(item, indent + 2);
+      const [first, ...rest] = nested;
+      lines.push(`${pad}- ${first ? first.trimStart() : "{}"}`);
+      for (const line of rest) lines.push(line);
+    }
+    return lines;
+  }
+  if (isRecord(value)) {
+    const entries = Object.entries(value).filter(([, v]) => v !== void 0);
+    if (!entries.length) return [`${pad}{}`];
+    const lines = [];
+    for (const [key, val] of entries) {
+      if (Array.isArray(val) && val.length === 0) {
+        lines.push(`${pad}${key}: []`);
+        continue;
+      }
+      if (isScalar(val)) {
+        lines.push(`${pad}${key}: ${formatScalar(val)}`);
+      } else {
+        lines.push(`${pad}${key}:`);
+        lines.push(...toYamlLines(val, indent + 2));
+      }
+    }
+    return lines;
+  }
+  return [`${pad}${formatScalar(value)}`];
+}
+function pruneTableDiff(table) {
+  const pruned = { name: table.name };
+  if (table.partition && table.partition.from !== table.partition.to) {
+    pruned.partition = table.partition;
+  }
+  if (table.identifier && !identifiersEqual(table.identifier.from ?? void 0, table.identifier.to ?? void 0)) {
+    pruned.identifier = table.identifier;
+  }
+  if (table.attributes) {
+    const { added = [], removed = [], changed = [] } = table.attributes;
+    if (added.length || removed.length || changed.length) {
+      pruned.attributes = { added, removed, changed };
+    }
+  }
+  if (table.indexes) {
+    const { added = [], removed = [], changed = [] } = table.indexes;
+    if (added.length || removed.length || changed.length) {
+      pruned.indexes = { added, removed, changed };
+    }
+  }
+  if (table.resolvers) {
+    const { added = [], removed = [], changed = [] } = table.resolvers;
+    if (added.length || removed.length || changed.length) {
+      pruned.resolvers = { added, removed, changed };
+    }
+  }
+  if (table.triggers) {
+    const { added = [], removed = [], changed = [] } = table.triggers;
+    if (added.length || removed.length || changed.length) {
+      pruned.triggers = { added, removed, changed };
+    }
+  }
+  const hasChange = pruned.partition || pruned.identifier || pruned.attributes && (pruned.attributes.added.length || pruned.attributes.removed.length || pruned.attributes.changed.length) || pruned.indexes && (pruned.indexes.added.length || pruned.indexes.removed.length || pruned.indexes.changed.length) || pruned.resolvers && (pruned.resolvers.added.length || pruned.resolvers.removed.length || pruned.resolvers.changed.length) || pruned.triggers && (pruned.triggers.added.length || pruned.triggers.removed.length || pruned.triggers.changed.length);
+  return hasChange ? pruned : null;
+}
+function formatSchemaDiff(diff, filePath) {
+  const hasChanges = diff.newTables.length || diff.removedTables.length || diff.changedTables.length;
+  if (!hasChanges) {
+    return `No differences found between API schema and ${filePath ?? "local schema"}.
+`;
+  }
+  const header = filePath ? `# Diff between API schema and ${filePath}
+` : "# Schema diff";
+  const prunedTables = diff.changedTables.map(pruneTableDiff).filter((t) => Boolean(t));
+  const yamlObject = {
+    newTables: [...diff.newTables],
+    removedTables: [...diff.removedTables],
+    changedTables: prunedTables
+  };
+  const bodyLines = toYamlLines(yamlObject);
+  return `${header}
+${bodyLines.join("\n")}
+`;
+}
+
 // src/impl/onyx.ts
 var DEFAULT_CACHE_TTL = 5 * 60 * 1e3;
 var cachedCfg = null;
@@ -969,6 +1334,10 @@ function serializeDates(value) {
   }
   return value;
 }
+function stripEntityText(input) {
+  const { entityText, ...rest } = input;
+  return rest;
+}
 function normalizeSecretMetadata(input) {
   return { ...input, updatedAt: new Date(input.updatedAt) };
 }
@@ -982,7 +1351,20 @@ function normalizeDate(value) {
   return Number.isNaN(ts.getTime()) ? void 0 : ts;
 }
 function normalizeSchemaRevision(input, fallbackDatabaseId) {
-  const { meta, createdAt, publishedAt, revisionId, ...rest } = input;
+  const {
+    meta,
+    createdAt,
+    publishedAt,
+    revisionId,
+    entityText,
+    databaseId,
+    entities,
+    revisionDescription,
+    ...rest
+  } = input;
+  const dbId = typeof databaseId === "string" ? databaseId : fallbackDatabaseId;
+  const entityList = Array.isArray(entities) ? entities : [];
+  const revisionDesc = typeof revisionDescription === "string" ? revisionDescription : void 0;
   const mergedMeta = {
     revisionId: meta?.revisionId ?? revisionId,
     createdAt: normalizeDate(meta?.createdAt ?? createdAt),
@@ -990,10 +1372,11 @@ function normalizeSchemaRevision(input, fallbackDatabaseId) {
   };
   const cleanedMeta = mergedMeta.revisionId || mergedMeta.createdAt || mergedMeta.publishedAt ? mergedMeta : void 0;
   return {
-    ...rest,
-    databaseId: input.databaseId ?? fallbackDatabaseId,
+    databaseId: dbId,
+    revisionDescription: revisionDesc,
+    entities: entityList,
     meta: cleanedMeta,
-    entities: input.entities ?? []
+    ...rest
   };
 }
 var OnyxDatabaseImpl = class {
@@ -1105,7 +1488,8 @@ var OnyxDatabaseImpl = class {
     const path2 = `/data/${encodeURIComponent(databaseId)}/${encodeURIComponent(
       table
     )}/${encodeURIComponent(primaryKey)}${params.toString() ? `?${params.toString()}` : ""}`;
-    return http.request("DELETE", path2);
+    await http.request("DELETE", path2);
+    return true;
   }
   async saveDocument(doc) {
     const { http, databaseId } = await this.ensureClient();
@@ -1148,20 +1532,32 @@ var OnyxDatabaseImpl = class {
     const res = await http.request("GET", path2);
     return Array.isArray(res) ? res.map((entry) => normalizeSchemaRevision(entry, databaseId)) : [];
   }
+  async diffSchema(localSchema) {
+    const apiSchema = await this.getSchema();
+    return computeSchemaDiff(apiSchema, localSchema);
+  }
   async updateSchema(schema, options) {
     const { http, databaseId } = await this.ensureClient();
     const params = new URLSearchParams();
     if (options?.publish) params.append("publish", "true");
     const path2 = `/schemas/${encodeURIComponent(databaseId)}${params.size ? `?${params.toString()}` : ""}`;
-    const body = { ...schema, databaseId: schema.databaseId ?? databaseId };
-    const res = await http.request("PUT", path2, serializeDates(body));
+    const body = stripEntityText({ ...schema, databaseId: schema.databaseId ?? databaseId });
+    const res = await http.request(
+      "PUT",
+      path2,
+      serializeDates(body)
+    );
     return normalizeSchemaRevision(res, databaseId);
   }
   async validateSchema(schema) {
     const { http, databaseId } = await this.ensureClient();
     const path2 = `/schemas/${encodeURIComponent(databaseId)}/validate`;
-    const body = { ...schema, databaseId: schema.databaseId ?? databaseId };
-    const res = await http.request("POST", path2, serializeDates(body));
+    const body = stripEntityText({ ...schema, databaseId: schema.databaseId ?? databaseId });
+    const res = await http.request(
+      "POST",
+      path2,
+      serializeDates(body)
+    );
     const normalizedSchema = res.schema ? normalizeSchemaRevision(res.schema, databaseId) : void 0;
     return {
       ...res,
@@ -1323,11 +1719,14 @@ var QueryBuilderImpl = class {
     if (!this.table) throw new Error("Table is not defined. Call from(<table>) first.");
     return this.table;
   }
+  serializableConditions() {
+    return normalizeCondition(this.conditions);
+  }
   toSelectQuery() {
     return {
       type: "SelectQuery",
       fields: this.fields,
-      conditions: this.conditions,
+      conditions: this.serializableConditions(),
       sort: this.sort,
       limit: this.limitValue,
       distinct: this.distinctValue,
@@ -1336,6 +1735,21 @@ var QueryBuilderImpl = class {
       resolvers: this.resolvers
     };
   }
+  toUpdateQuery() {
+    return {
+      type: "UpdateQuery",
+      conditions: this.serializableConditions(),
+      updates: this.updates ?? {},
+      sort: this.sort,
+      limit: this.limitValue,
+      partition: this.partitionValue ?? null
+    };
+  }
+  toSerializableQueryObject() {
+    const table = this.ensureTable();
+    const payload = this.mode === "update" ? this.toUpdateQuery() : this.toSelectQuery();
+    return { ...payload, table };
+  }
   from(table) {
     this.table = table;
     return this;
@@ -1471,14 +1885,7 @@ var QueryBuilderImpl = class {
   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
-    };
+    const update = this.toUpdateQuery();
     return this.db._update(table, update, this.partitionValue);
   }
   onItemAdded(listener) {
@@ -1570,10 +1977,13 @@ Usage:
   onyx-schema publish [file]
   onyx-schema get [file] [--tables tableA,tableB]
   onyx-schema validate [file]
+  onyx-schema diff [file]
+  onyx-schema info
 
 Options:
   [file]                 Path to schema JSON (default: ./onyx.schema.json)
   --tables <list>        Comma-separated list of tables to fetch (for get)
+  --print                Print the fetched schema to stdout instead of writing a file
   -h, --help             Show this help message
 `);
 }
@@ -1585,7 +1995,7 @@ function parseTables(value) {
 function parseArgs(argv) {
   const cmd = (argv[2] ?? "").toLowerCase();
   let command = "help";
-  if (cmd === "publish" || cmd === "get" || cmd === "validate") {
+  if (cmd === "publish" || cmd === "get" || cmd === "validate" || cmd === "diff" || cmd === "info") {
     command = cmd;
   }
   let idx = 3;
@@ -1595,6 +2005,7 @@ function parseArgs(argv) {
     idx++;
   }
   let tables;
+  let print = false;
   for (; idx < argv.length; idx++) {
     const arg = argv[idx];
     switch (arg) {
@@ -1602,6 +2013,9 @@ function parseArgs(argv) {
         tables = parseTables(argv[idx + 1]);
         idx++;
         break;
+      case "--print":
+        print = true;
+        break;
       case "-h":
       case "--help":
         command = "help";
@@ -1616,7 +2030,7 @@ function parseArgs(argv) {
       }
     }
   }
-  return { command, filePath, tables };
+  return { command, filePath, tables, print };
 }
 async function readFileJson(filePath) {
   const fs = await import('fs/promises');
@@ -1631,10 +2045,10 @@ async function writeFileJson(filePath, data) {
 `;
   await fs.writeFile(resolved, serialized, "utf8");
 }
-async function fetchSchema(filePath, tables) {
+async function fetchSchema(filePath, tables, print) {
   const db = onyx.init();
   const schema = await db.getSchema({ tables });
-  if (tables?.length) {
+  if (tables?.length || print) {
     process__default.default.stdout.write(`${JSON.stringify(schema, null, 2)}
 `);
     return;
@@ -1670,6 +2084,47 @@ ${formatSchemaErrors(result.errors)}`);
   process__default.default.stdout.write(`Schema published for database ${revision.databaseId} from ${filePath}.
 `);
 }
+async function diffSchema(filePath) {
+  const db = onyx.init();
+  const localSchema = await readFileJson(filePath);
+  const diff = await db.diffSchema(localSchema);
+  const output = formatSchemaDiff(diff, filePath);
+  process__default.default.stdout.write(output);
+}
+function maskValue(value) {
+  if (!value) return "";
+  if (value.length <= 4) return value;
+  return `${value.slice(0, 2)}...${value.slice(-2)}`;
+}
+function formatSource(source) {
+  if (!source) return "unknown";
+  if (source.includes("env")) return "env";
+  if (source.includes("file") || source.includes("profile") || source.includes("config")) return "file";
+  if (source === "explicit config") return "explicit";
+  return source;
+}
+async function printInfo() {
+  const resolved = await resolveConfigWithSource();
+  const db = onyx.init();
+  const cfgFile = resolved.sources.configPath ?? resolved.sources.projectFile ?? resolved.sources.homeProfile ?? "(none)";
+  let connection = "ok";
+  try {
+    await db.getSchema({ tables: [] });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    connection = msg;
+  }
+  const lines = [
+    `Database ID: ${resolved.databaseId} (source: ${formatSource(resolved.sources.databaseId)})`,
+    `Base URL   : ${resolved.baseUrl} (source: ${formatSource(resolved.sources.baseUrl)})`,
+    `API Key    : ${maskValue(resolved.apiKey)} (source: ${formatSource(resolved.sources.apiKey)})`,
+    `API Secret : ${maskValue(resolved.apiSecret)} (source: ${formatSource(resolved.sources.apiSecret)})`,
+    `Config file: ${cfgFile}`,
+    `Connection : ${connection}`
+  ];
+  process__default.default.stdout.write(`${lines.join("\n")}
+`);
+}
 (async () => {
   try {
     const parsed = parseArgs(process__default.default.argv);
@@ -1678,11 +2133,17 @@ ${formatSchemaErrors(result.errors)}`);
         await publishSchema(parsed.filePath);
         break;
       case "get":
-        await fetchSchema(parsed.filePath, parsed.tables);
+        await fetchSchema(parsed.filePath, parsed.tables, parsed.print);
         break;
       case "validate":
         await validateSchema(parsed.filePath);
         break;
+      case "diff":
+        await diffSchema(parsed.filePath);
+        break;
+      case "info":
+        await printInfo();
+        break;
       default:
         printHelp();
         return;