@onyx.dev/onyx-database 0.3.0 → 1.0.0

package/README.md

@@ -174,6 +174,10 @@ onyx-schema get --tables=User,Profile
 
 # Validate a schema file without publishing
 onyx-schema validate ./onyx.schema.json
+
+# Diff local schema vs API
+onyx-schema diff ./onyx.schema.json
+# Prints added/removed/changed tables and attribute differences between the API schema and your local file.
 ```
 
 When `--tables` is provided, the subset is printed to stdout instead of writing a
@@ -322,7 +326,9 @@ Importable helpers for conditions and sort:
 
 ```ts
 import {
-  eq, neq, inOp, notIn, between,
+  eq, neq, within, notWithin, // preferred aliases for IN/NOT IN
+  inOp, notIn,           
+  between,
   gt, gte, lt, lte,
   like, notLike, contains, notContains,
   startsWith, notStartsWith, matches, notMatches,
@@ -331,6 +337,41 @@ import {
 } from '@onyx.dev/onyx-database';
 ```
 
+- Prefer `within`/`notWithin` for inclusion checks (supports arrays, comma-separated strings, or inner queries).  
+- `inOp`/`notIn` remain available for backward compatibility and are exact aliases.
+
+### Inner queries (IN/NOT IN with sub-selects)
+
+You can pass another query builder to `within` or `notWithin` to create nested filters. The SDK serializes the inner query (including its table) before sending the request.
+
+```ts
+import { onyx, within, notWithin, eq, tables, Schema } from '@onyx.dev/onyx-database';
+
+const db = onyx.init<Schema>();
+
+// Users that HAVE the admin role
+const usersWithAdmin = await db
+  .from(tables.User)
+  .where(
+    within(
+      'id',
+      db.select('userId').from(tables.UserRole).where(eq('roleId', 'role-admin')),
+    ),
+  )
+  .list();
+
+// Roles that DO NOT include a specific permission
+const rolesMissingPermission = await db
+  .from(tables.Role)
+  .where(
+    notWithin(
+      'id',
+      db.from(tables.RolePermission).where(eq('permissionId', 'perm-manage-users')),
+    ),
+  )
+  .list();
+```
+
 ---
 
 ## Usage examples with `User`, `Role`, `Permission`

package/dist/gen/cli/generate.cjs

@@ -931,6 +931,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;
@@ -1058,6 +1108,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) };
 }
@@ -1071,7 +1125,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),
@@ -1242,15 +1296,23 @@ var OnyxDatabaseImpl = class {
     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));
+    const body = stripEntityText({ ...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 body = stripEntityText({ ...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,
@@ -1412,11 +1474,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,
@@ -1425,6 +1490,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;
@@ -1560,14 +1640,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) {