@rocicorp/zero 0.7.2024112700 → 0.7.2024120101

package/out/{chunk-HDEKBM3G.js → chunk-5S7LFUZ4.js}

@@ -3106,13 +3106,13 @@ var DataNodeImpl = class extends NodeImpl {
     }
   }
 };
-function readonlySplice(array9, start, deleteCount, ...items) {
-  const arr = array9.slice(0, start);
+function readonlySplice(array10, start, deleteCount, ...items) {
+  const arr = array10.slice(0, start);
   for (let i = 0; i < items.length; i++) {
     arr.push(items[i]);
   }
-  for (let i = start + deleteCount; i < array9.length; i++) {
-    arr.push(array9[i]);
+  for (let i = start + deleteCount; i < array10.length; i++) {
+    arr.push(array10[i]);
   }
   return arr;
 }
@@ -8091,14 +8091,14 @@ function diffBinarySearch(diff2, prefix, compareKey) {
 }
 
 // ../shared/src/random-values.ts
-function getNonCryptoRandomValues(array9) {
-  if (array9 === null) {
+function getNonCryptoRandomValues(array10) {
+  if (array10 === null) {
     throw new TypeError("array cannot be null");
   }
-  for (let i = 0; i < array9.length; i++) {
-    array9[i] = Math.floor(Math.random() * 256);
+  for (let i = 0; i < array10.length; i++) {
+    array10[i] = Math.floor(Math.random() * 256);
   }
-  return array9;
+  return array10;
 }
 
 // ../replicache/src/sync/request-id.ts
@@ -9284,10 +9284,10 @@ function createTableSchema(schema) {
   return schema;
 }
 function isFieldRelationship(relationship) {
-  return relationship.junction === void 0;
+  return !isJunctionRelationship(relationship);
 }
 function isJunctionRelationship(relationship) {
-  return !isFieldRelationship(relationship);
+  return Array.isArray(relationship);
 }
 
 // ../shared/src/sorted-entries.ts
@@ -9338,24 +9338,13 @@ function normalizeTableSchemaWithCache(tableSchema, expectedName, tableSchemaCac
   );
   return normalizedTableSchema;
 }
-function isSorted(arr) {
-  for (let i = 1; i < arr.length; i++) {
-    if (arr[i - 1] >= arr[i]) {
-      return false;
-    }
-  }
-  return true;
-}
 function assertNoDuplicates(arr) {
-  for (let i = 1; i < arr.length; i++) {
-    assert(arr[i - 1] !== arr[i], "Primary key must not contain duplicates");
-  }
+  assert(
+    new Set(arr).size === arr.length,
+    "Primary key must not contain duplicates"
+  );
 }
 function normalizePrimaryKey(arr) {
-  if (isSorted(arr)) {
-    return arr;
-  }
-  arr = [...arr].sort();
   assertNoDuplicates(arr);
   return arr;
 }
@@ -9396,26 +9385,25 @@ function normalizeRelationship(relationship, tableSchemaCache) {
   return normalizeJunctionRelationship(relationship, tableSchemaCache);
 }
 function normalizeFieldRelationship(relationship, tableSchemaCache) {
+  assert(
+    relationship.sourceField.length === relationship.destField.length,
+    "Source and destination fields must have the same length"
+  );
   return {
-    source: relationship.source,
-    dest: {
-      field: relationship.dest.field,
-      schema: normalizeLazyTableSchema(
-        relationship.dest.schema,
-        tableSchemaCache
-      )
-    }
-  };
-}
-function normalizeJunctionRelationship(relationship, tableSchemaCache) {
-  return {
-    ...normalizeFieldRelationship(relationship, tableSchemaCache),
-    junction: normalizeFieldRelationship(
-      relationship.junction,
+    sourceField: relationship.sourceField,
+    destField: relationship.destField,
+    destSchema: normalizeLazyTableSchema(
+      relationship.destSchema,
       tableSchemaCache
     )
   };
 }
+function normalizeJunctionRelationship(relationship, tableSchemaCache) {
+  return [
+    normalizeFieldRelationship(relationship[0], tableSchemaCache),
+    normalizeFieldRelationship(relationship[1], tableSchemaCache)
+  ];
+}
 function normalizeLazyTableSchema(tableSchema, buildCache) {
   const tableSchemaInstance = typeof tableSchema === "function" ? tableSchema() : tableSchema;
   return normalizeTableSchemaWithCache(
@@ -9592,8 +9580,8 @@ var negateOperatorMap = {
 function negateOperator(op) {
   return must(negateOperatorMap[op]);
 }
-function filterUndefined(array9) {
-  return array9.filter((e) => e !== void 0);
+function filterUndefined(array10) {
+  return array10.filter((e) => e !== void 0);
 }
 function filterTrue(conditions) {
   return conditions.filter((c) => !isAlwaysTrue(c));
@@ -9722,12 +9710,13 @@ var disjunctionSchema = readonlyObject({
   type: valita_exports.literal("or"),
   conditions: readonlyArray(conditionSchema)
 });
+var compoundKeySchema = valita_exports.tuple([valita_exports.string()]).concat(valita_exports.array(valita_exports.string()));
+var correlationSchema = readonlyObject({
+  parentField: compoundKeySchema,
+  childField: compoundKeySchema
+});
 var correlatedSubquerySchemaOmitSubquery = readonlyObject({
-  correlation: valita_exports.object({
-    parentField: valita_exports.string(),
-    childField: valita_exports.string(),
-    op: valita_exports.literal("=")
-  }),
+  correlation: correlationSchema,
   hidden: valita_exports.boolean().optional()
 });
 var correlatedSubquerySchema = correlatedSubquerySchemaOmitSubquery.extend({
@@ -9761,11 +9750,7 @@ function normalizeAST(ast) {
     related: ast.related ? sortedRelated(
       ast.related.map(
         (r) => ({
-          correlation: {
-            parentField: r.correlation.parentField,
-            childField: r.correlation.childField,
-            op: r.correlation.op
-          },
+          correlation: r.correlation,
           hidden: r.hidden,
           subquery: normalizeAST(r.subquery)
         })
@@ -11340,12 +11325,7 @@ function buildPipelineInternal(ast, delegate, partitionKey) {
     end = applyWhere(end, ast.where, appliedFilters, delegate);
   }
   if (ast.limit) {
-    end = new Take(
-      end,
-      delegate.createStorage(),
-      ast.limit,
-      partitionKey === void 0 ? void 0 : [partitionKey]
-    );
+    end = new Take(end, delegate.createStorage(), ast.limit, partitionKey);
   }
   if (ast.related) {
     for (const csq of ast.related) {
@@ -11397,9 +11377,8 @@ function applyCorrelatedSubQuery(sq, delegate, end) {
     parent: end,
     child,
     storage: delegate.createStorage(),
-    // TODO: Compound keys in the AST
-    parentKey: [sq.correlation.parentField],
-    childKey: [sq.correlation.childField],
+    parentKey: sq.correlation.parentField,
+    childKey: sq.correlation.childField,
     relationshipName: sq.subquery.alias,
     hidden: sq.hidden ?? false
   });
@@ -11688,10 +11667,8 @@ var AbstractQuery = class {
     }
     const related = this.#schema.relationships[relationship];
     assert(related, "Invalid relationship");
-    const fieldRelationship = related;
-    const junctionRelationship = related;
-    if (isFieldRelationship(fieldRelationship)) {
-      const destSchema = fieldRelationship.dest.schema;
+    if (isFieldRelationship(related)) {
+      const { destSchema } = related;
       const sq = cb(
         this._newQuery(
           destSchema,
@@ -11710,9 +11687,8 @@ var AbstractQuery = class {
             ...this.#ast.related ?? [],
             {
               correlation: {
-                parentField: fieldRelationship.source,
-                childField: fieldRelationship.dest.field,
-                op: "="
+                parentField: related.sourceField,
+                childField: related.destField
               },
               subquery: addPrimaryKeysToAst(destSchema, sq.#ast)
             }
@@ -11727,9 +11703,11 @@ var AbstractQuery = class {
         }
       );
     }
-    if (isJunctionRelationship(junctionRelationship)) {
-      const destSchema = junctionRelationship.dest.schema;
-      const junctionSchema = junctionRelationship.junction.dest.schema;
+    if (isJunctionRelationship(related)) {
+      assert(related.length === 2, "Invalid relationship");
+      const [firstRelation, secondRelation] = related;
+      const { destSchema } = secondRelation;
+      const junctionSchema = firstRelation.destSchema;
       const sq = cb(
         this._newQuery(
           destSchema,
@@ -11748,9 +11726,8 @@ var AbstractQuery = class {
             ...this.#ast.related ?? [],
             {
               correlation: {
-                parentField: junctionRelationship.source,
-                childField: junctionRelationship.junction.source,
-                op: "="
+                parentField: firstRelation.sourceField,
+                childField: firstRelation.destField
               },
               subquery: {
                 table: junctionSchema.tableName,
@@ -11759,9 +11736,8 @@ var AbstractQuery = class {
                 related: [
                   {
                     correlation: {
-                      parentField: junctionRelationship.junction.dest.field,
-                      childField: junctionRelationship.dest.field,
-                      op: "="
+                      parentField: secondRelation.sourceField,
+                      childField: secondRelation.destField
                     },
                     hidden: true,
                     subquery: addPrimaryKeysToAst(destSchema, sq.#ast)
@@ -11845,10 +11821,8 @@ var AbstractQuery = class {
   _exists = (relationship, cb = (q) => q) => {
     const related = this.#schema.relationships[relationship];
     assert(related, "Invalid relationship");
-    const fieldRelationship = related;
-    const junctionRelationship = related;
-    if (isFieldRelationship(fieldRelationship)) {
-      const destSchema = fieldRelationship.dest.schema;
+    if (isFieldRelationship(related)) {
+      const { destSchema } = related;
       const sq = cb(
         this._newQuery(
           destSchema,
@@ -11863,18 +11837,19 @@ var AbstractQuery = class {
         type: "correlatedSubquery",
         related: {
           correlation: {
-            parentField: fieldRelationship.source,
-            childField: fieldRelationship.dest.field,
-            op: "="
+            parentField: related.sourceField,
+            childField: related.destField
           },
           subquery: addPrimaryKeysToAst(destSchema, sq.#ast)
         },
         op: "EXISTS"
       };
     }
-    if (isJunctionRelationship(junctionRelationship)) {
-      const destSchema = junctionRelationship.dest.schema;
-      const junctionSchema = junctionRelationship.junction.dest.schema;
+    if (isJunctionRelationship(related)) {
+      assert(related.length === 2, "Invalid relationship");
+      const [firstRelation, secondRelation] = related;
+      const { destSchema } = secondRelation;
+      const junctionSchema = firstRelation.destSchema;
       const queryToDest = cb(
         this._newQuery(
           destSchema,
@@ -11889,9 +11864,8 @@ var AbstractQuery = class {
         type: "correlatedSubquery",
         related: {
           correlation: {
-            parentField: junctionRelationship.source,
-            childField: junctionRelationship.junction.source,
-            op: "="
+            parentField: firstRelation.sourceField,
+            childField: firstRelation.destField
           },
           subquery: {
             table: junctionSchema.tableName,
@@ -11901,9 +11875,8 @@ var AbstractQuery = class {
               type: "correlatedSubquery",
               related: {
                 correlation: {
-                  parentField: junctionRelationship.junction.dest.field,
-                  childField: junctionRelationship.dest.field,
-                  op: "="
+                  parentField: secondRelation.sourceField,
+                  childField: secondRelation.destField
                 },
                 subquery: addPrimaryKeysToAst(destSchema, queryToDest.#ast)
               },
@@ -12056,17 +12029,17 @@ var AuthQuery = class _AuthQuery extends AbstractQuery {
   }
 };
 
-// ../zero-schema/src/authorization.ts
-async function defineAuthorization(schema, definer) {
+// ../zero-schema/src/permissions.ts
+async function definePermissions(schema, definer) {
   const normalizedSchema = normalizeSchema(schema);
   const expressionBuilders = {};
   for (const [name, tableSchema] of Object.entries(normalizedSchema.tables)) {
     expressionBuilders[name] = new AuthQuery(tableSchema).expressionBuilder();
   }
   const config = await definer();
-  return compileAuthorization(config, expressionBuilders);
+  return compilePermissions(config, expressionBuilders);
 }
-function compileAuthorization(authz, expressionBuilders) {
+function compilePermissions(authz, expressionBuilders) {
   if (!authz) {
     return void 0;
   }
@@ -14381,17 +14354,17 @@ var MemorySource = class {
     switch (change.type) {
       case "add":
         if (data.has(change.row)) {
-          throw new Error(`Row already exists: ` + JSON.stringify(change));
+          throw new Error(`Row already exists ${JSON.stringify(change)}`);
         }
         break;
       case "remove":
         if (!data.has(change.row)) {
-          throw new Error(`Row not found: ` + JSON.stringify(change));
+          throw new Error(`Row not found ${JSON.stringify(change)}`);
         }
         break;
       case "edit":
         if (!data.has(change.oldRow)) {
-          throw new Error(`Row not found: ` + JSON.stringify(change));
+          throw new Error(`Row not found ${JSON.stringify(change)}`);
         }
         break;
       default:
@@ -15246,7 +15219,7 @@ function makeMessage(message, context, logLevel) {
 }
 
 // ../zero-client/src/client/version.ts
-var version2 = "0.7.2024112700+dfe437";
+var version2 = "0.7.2024120101+5cb996";
 
 // ../zero-client/src/client/log-options.ts
 var LevelFilterLogSink = class {
@@ -17231,9 +17204,9 @@ export {
   dropDatabase,
   dropAllDatabases,
   createTableSchema,
-  defineAuthorization,
+  definePermissions,
   createSchema,
   escapeLike,
   Zero
 };
-//# sourceMappingURL=chunk-HDEKBM3G.js.map
+//# sourceMappingURL=chunk-5S7LFUZ4.js.map