@onyx.dev/onyx-database 0.3.0 → 1.0.0

package/dist/schema/cli/schema.cjs

@@ -842,6 +842,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;
@@ -969,6 +1019,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 +1036,7 @@ 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, ...rest } = input;
   const mergedMeta = {
     revisionId: meta?.revisionId ?? revisionId,
     createdAt: normalizeDate(meta?.createdAt ?? createdAt),
@@ -1153,15 +1207,23 @@ var OnyxDatabaseImpl = class {
     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 +1385,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 +1401,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 +1551,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) {
@@ -1561,6 +1634,212 @@ var onyx = {
   clearCacheConfig
 };
 
+// schema/cli/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 formatIdentifier(id) {
+  if (!id) return "";
+  const parts = [id.name ? `name=${id.name}` : null, id.generator ? `generator=${id.generator}` : null, id.type ? `type=${id.type}` : null].filter(Boolean);
+  return parts.join(", ");
+}
+function describeIdentifierChange(api, local) {
+  if (!api && !local) return null;
+  if (!api && local) return "identifier removed";
+  if (api && !local) return "identifier added";
+  if (!api || !local) return null;
+  if (api.name === local.name && api.generator === local.generator && api.type === local.type) {
+    return null;
+  }
+  return `identifier: ${formatIdentifier(api) || "none"} -> ${formatIdentifier(local) || "none"}`;
+}
+function describePartitionChange(api, local) {
+  const norm = (v) => v == null || v === "" ? "" : v;
+  if (norm(api) === norm(local)) return null;
+  return `partition: ${norm(api) || "none"} -> ${norm(local) || "none"}`;
+}
+function describeAttribute(attr) {
+  const nullable = attr.isNullable ? "true" : "false";
+  return `${attr.name} (${attr.type ?? "unknown"}, nullable: ${nullable})`;
+}
+function describeAttributeChange(api, local) {
+  const diffs = [];
+  if (api.type !== local.type) {
+    diffs.push(`type ${api.type ?? "unknown"} -> ${local.type ?? "unknown"}`);
+  }
+  const apiNull = Boolean(api.isNullable);
+  const localNull = Boolean(local.isNullable);
+  if (apiNull !== localNull) {
+    diffs.push(`nullable ${apiNull} -> ${localNull}`);
+  }
+  if (!diffs.length) return null;
+  return `${local.name}: ${diffs.join("; ")}`;
+}
+function describeIndex(idx) {
+  const parts = [`type: ${idx.type ?? "DEFAULT"}`];
+  if (idx.minimumScore != null) parts.push(`minScore: ${idx.minimumScore}`);
+  return `${idx.name} (${parts.join(", ")})`;
+}
+function describeIndexChange(api, local) {
+  const diffs = [];
+  if (api.type !== local.type) {
+    diffs.push(`type ${api.type ?? "DEFAULT"} -> ${local.type ?? "DEFAULT"}`);
+  }
+  if (api.minimumScore !== local.minimumScore) {
+    diffs.push(`minScore ${api.minimumScore ?? "none"} -> ${local.minimumScore ?? "none"}`);
+  }
+  if (!diffs.length) return null;
+  return `${local.name}: ${diffs.join("; ")}`;
+}
+function describeResolverChange(api, local) {
+  if (api.resolver === local.resolver) return null;
+  return `${local.name}: resolver changed`;
+}
+function describeTrigger(trigger) {
+  return `${trigger.name} (${trigger.event})`;
+}
+function describeTriggerChange(api, local) {
+  const diffs = [];
+  if (api.event !== local.event) {
+    diffs.push(`event ${api.event ?? "none"} -> ${local.event ?? "none"}`);
+  }
+  if (api.trigger !== local.trigger) {
+    diffs.push("trigger changed");
+  }
+  if (!diffs.length) return null;
+  return `${local.name}: ${diffs.join("; ")}`;
+}
+function diffCollections(apiItems, localItems, describeAdd, describeChange) {
+  const apiMap = mapByName(apiItems);
+  const localMap = mapByName(localItems);
+  const added = [];
+  const removed = [];
+  const changed = [];
+  for (const [name, local] of localMap.entries()) {
+    if (!apiMap.has(name)) {
+      added.push(describeAdd(local));
+      continue;
+    }
+    if (describeChange) {
+      const detail = describeChange(apiMap.get(name), local);
+      if (detail) changed.push(detail);
+    }
+  }
+  for (const name of apiMap.keys()) {
+    if (!localMap.has(name)) removed.push(name);
+  }
+  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 details = [];
+    const partitionChange = describePartitionChange(apiEntity.partition, localEntity.partition);
+    if (partitionChange) details.push(partitionChange);
+    const idChange = describeIdentifierChange(apiEntity.identifier, localEntity.identifier);
+    if (idChange) details.push(idChange);
+    const attrDiff = diffCollections(apiEntity.attributes, localEntity.attributes, (attr) => `+ ${describeAttribute(attr)}`, describeAttributeChange);
+    if (attrDiff.added.length || attrDiff.removed.length || attrDiff.changed.length) {
+      details.push("attributes:");
+      for (const a of attrDiff.added) details.push(`  ${a}`);
+      for (const c of attrDiff.changed) details.push(`  ~ ${c}`);
+      for (const r of attrDiff.removed) details.push(`  - ${r}`);
+    }
+    const idxDiff = diffCollections(apiEntity.indexes, localEntity.indexes, (idx) => `+ ${describeIndex(idx)}`, describeIndexChange);
+    if (idxDiff.added.length || idxDiff.removed.length || idxDiff.changed.length) {
+      details.push("indexes:");
+      for (const a of idxDiff.added) details.push(`  ${a}`);
+      for (const c of idxDiff.changed) details.push(`  ~ ${c}`);
+      for (const r of idxDiff.removed) details.push(`  - ${r}`);
+    }
+    const resolverDiff = diffCollections(apiEntity.resolvers, localEntity.resolvers, (resolver) => `+ ${resolver.name}`, describeResolverChange);
+    if (resolverDiff.added.length || resolverDiff.removed.length || resolverDiff.changed.length) {
+      details.push("resolvers:");
+      for (const a of resolverDiff.added) details.push(`  ${a}`);
+      for (const c of resolverDiff.changed) details.push(`  ~ ${c}`);
+      for (const r of resolverDiff.removed) details.push(`  - ${r}`);
+    }
+    const triggerDiff = diffCollections(apiEntity.triggers, localEntity.triggers, (trigger) => `+ ${describeTrigger(trigger)}`, describeTriggerChange);
+    if (triggerDiff.added.length || triggerDiff.removed.length || triggerDiff.changed.length) {
+      details.push("triggers:");
+      for (const a of triggerDiff.added) details.push(`  ${a}`);
+      for (const c of triggerDiff.changed) details.push(`  ~ ${c}`);
+      for (const r of triggerDiff.removed) details.push(`  - ${r}`);
+    }
+    if (details.length) {
+      changedTables.push({ name, details });
+    }
+  }
+  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 formatSchemaDiff(diff, filePath) {
+  const lines = [];
+  const hasChanges = diff.newTables.length || diff.removedTables.length || diff.changedTables.length;
+  if (!hasChanges) {
+    return `No differences found between API schema and ${filePath ?? "local file"}.
+`;
+  }
+  if (filePath) lines.push(`Comparing API schema to ${filePath}`);
+  lines.push("New Tables:");
+  if (diff.newTables.length) {
+    for (const t of diff.newTables) lines.push(`  ${t}`);
+  } else {
+    lines.push("  (none)");
+  }
+  lines.push("Removed Tables:");
+  if (diff.removedTables.length) {
+    for (const t of diff.removedTables) lines.push(`  ${t}`);
+  } else {
+    lines.push("  (none)");
+  }
+  lines.push("Changes:");
+  if (diff.changedTables.length) {
+    for (const table of diff.changedTables) {
+      lines.push(`  ${table.name}`);
+      for (const detail of table.details) {
+        lines.push(`      ${detail}`);
+      }
+    }
+  } else {
+    lines.push("  (none)");
+  }
+  return `${lines.join("\n")}
+`;
+}
+
 // schema/cli/schema.ts
 var DEFAULT_SCHEMA_PATH = "./onyx.schema.json";
 function printHelp() {
@@ -1570,6 +1849,7 @@ Usage:
   onyx-schema publish [file]
   onyx-schema get [file] [--tables tableA,tableB]
   onyx-schema validate [file]
+  onyx-schema diff [file]
 
 Options:
   [file]                 Path to schema JSON (default: ./onyx.schema.json)
@@ -1585,7 +1865,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") {
     command = cmd;
   }
   let idx = 3;
@@ -1670,6 +1950,16 @@ ${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 [apiSchema, localSchema] = await Promise.all([
+    db.getSchema(),
+    readFileJson(filePath)
+  ]);
+  const diff = computeSchemaDiff(apiSchema, localSchema);
+  const output = formatSchemaDiff(diff, filePath);
+  process__default.default.stdout.write(output);
+}
 (async () => {
   try {
     const parsed = parseArgs(process__default.default.argv);
@@ -1683,6 +1973,9 @@ ${formatSchemaErrors(result.errors)}`);
       case "validate":
         await validateSchema(parsed.filePath);
         break;
+      case "diff":
+        await diffSchema(parsed.filePath);
+        break;
       default:
         printHelp();
         return;