@korajs/server 1.0.0-beta.2 → 1.0.0-beta.4

package/dist/index.cjs

@@ -3277,6 +3277,57 @@ var YjsDocRelay = class {
 // src/server/route-context.ts
 init_cjs_shims();
 var import_core12 = require("@korajs/core");
+
+// src/apply/route-predicate.ts
+init_cjs_shims();
+function evaluateField(actual, operators) {
+  if ("$eq" in operators && !Object.is(actual, operators.$eq)) {
+    return false;
+  }
+  if ("$ne" in operators && Object.is(actual, operators.$ne)) {
+    return false;
+  }
+  if (operators.$in !== void 0 && !operators.$in.some((candidate) => Object.is(actual, candidate))) {
+    return false;
+  }
+  const numericChecks = [
+    ["$lt", (a, b) => a < b],
+    ["$lte", (a, b) => a <= b],
+    ["$gt", (a, b) => a > b],
+    ["$gte", (a, b) => a >= b]
+  ];
+  for (const [operator, compare] of numericChecks) {
+    const bound = operators[operator];
+    if (bound === void 0) {
+      continue;
+    }
+    if (typeof actual !== "number" || typeof bound !== "number") {
+      return false;
+    }
+    if (!compare(actual, bound)) {
+      return false;
+    }
+  }
+  return true;
+}
+function evaluateRoutePredicate(record, predicate) {
+  const fields = Object.keys(predicate);
+  if (fields.length === 0) {
+    return true;
+  }
+  if (record === null) {
+    return false;
+  }
+  for (const field of fields) {
+    const operators = predicate[field];
+    if (operators && !evaluateField(record[field], operators)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// src/server/route-context.ts
 function recordMatchesScope(collection, record, scope) {
   const collectionScope = scope[collection];
   if (!collectionScope) {
@@ -3327,7 +3378,18 @@ async function buildRouteOperation(store, mutation) {
   }
   const current = await store.findRecord(mutation.collection, mutation.recordId);
   if (mutation.type === "update") {
-    const data = mutation.data ?? {};
+    const rawData = mutation.data ?? {};
+    const data = {};
+    const atomicOps = {};
+    for (const key of Object.keys(rawData)) {
+      const value = rawData[key];
+      if ((0, import_core12.isAtomicOp)(value)) {
+        data[key] = (0, import_core12.resolveAtomicOp)(current ? current[key] : void 0, value);
+        atomicOps[key] = (0, import_core12.toAtomicOp)(value);
+      } else {
+        data[key] = value;
+      }
+    }
     return (0, import_core12.createOperation)(
       {
         nodeId,
@@ -3335,10 +3397,11 @@ async function buildRouteOperation(store, mutation) {
         collection: mutation.collection,
         recordId: mutation.recordId,
         data,
-        previousData: current ? pickFields(current, Object.keys(data)) : {},
+        previousData: current ? pickFields(current, Object.keys(rawData)) : {},
         sequenceNumber,
         causalDeps: [],
-        schemaVersion
+        schemaVersion,
+        ...Object.keys(atomicOps).length > 0 ? { atomicOps } : {}
       },
       clock
     );
@@ -3376,45 +3439,123 @@ function createRouteContext(server, store) {
     );
     return run;
   }
+  async function prepareMutation(mutation, scope) {
+    let op;
+    try {
+      op = await buildRouteOperation(store, mutation);
+    } catch (error) {
+      if (error instanceof RouteMutationError) {
+        return {
+          ok: false,
+          rejection: {
+            ok: false,
+            code: error.code,
+            message: error.message,
+            retriable: isRetriableRejection(error.code)
+          }
+        };
+      }
+      throw error;
+    }
+    if (scope && !operationMatchesScopes(op, scope)) {
+      return {
+        ok: false,
+        rejection: {
+          ok: false,
+          code: "SCOPE_VIOLATION",
+          message: `Mutation on "${mutation.collection}" is outside the provided scope.`,
+          retriable: isRetriableRejection("SCOPE_VIOLATION")
+        }
+      };
+    }
+    return { ok: true, op };
+  }
+  async function commitOperation(op, collection) {
+    const result = await server.applyLocalOperation(op);
+    if (result.result !== "applied") {
+      const code = result.rejection?.code ?? "NOT_APPLIED";
+      return {
+        ok: false,
+        code,
+        message: result.rejection?.message ?? `Operation on "${collection}" was not applied (${result.result}).`,
+        // Prefer the pipeline's own classification when present; fall back
+        // to classifying the code so this stays correct if new codes appear.
+        retriable: result.rejection?.retriable ?? isRetriableRejection(code)
+      };
+    }
+    const record = await store.findRecord(collection, op.recordId);
+    return { ok: true, operation: op, record };
+  }
+  async function rawApply(mutation, scope) {
+    const prepared = await prepareMutation(mutation, scope);
+    if (!prepared.ok) {
+      return prepared.rejection;
+    }
+    return commitOperation(prepared.op, mutation.collection);
+  }
   return {
     apply(mutation, options) {
+      return serialize(() => rawApply(mutation, options?.scope));
+    },
+    applyConditional(spec, options) {
       return serialize(async () => {
-        let op;
-        try {
-          op = await buildRouteOperation(store, mutation);
-        } catch (error) {
-          if (error instanceof RouteMutationError) {
+        if (spec.idempotencyKey) {
+          const existing = await store.findRecord(
+            spec.idempotencyKey.collection,
+            spec.idempotencyKey.id
+          );
+          if (existing) {
+            return { ok: true, idempotent: true, operations: [], records: [existing] };
+          }
+        }
+        if (spec.if && Object.keys(spec.if).length > 0) {
+          const target = await store.findRecord(spec.collection, spec.id);
+          if (!evaluateRoutePredicate(target, spec.if)) {
+            const code = spec.reject?.code ?? "CONDITION_NOT_MET";
             return {
               ok: false,
-              code: error.code,
-              message: error.message,
-              retriable: isRetriableRejection(error.code)
+              code,
+              message: spec.reject?.message ?? `Admission condition not met on "${spec.collection}" record "${spec.id}".`,
+              retriable: false
             };
           }
-          throw error;
         }
-        if (options?.scope && !operationMatchesScopes(op, options.scope)) {
-          return {
-            ok: false,
-            code: "SCOPE_VIOLATION",
-            message: `Mutation on "${mutation.collection}" is outside the provided scope.`,
-            retriable: isRetriableRejection("SCOPE_VIOLATION")
-          };
+        const mutations = [];
+        if (spec.update !== void 0 && spec.update !== null) {
+          mutations.push({
+            collection: spec.collection,
+            type: "update",
+            recordId: spec.id,
+            data: spec.update
+          });
         }
-        const result = await server.applyLocalOperation(op);
-        if (result.result !== "applied") {
-          const code = result.rejection?.code ?? "NOT_APPLIED";
-          return {
-            ok: false,
-            code,
-            message: result.rejection?.message ?? `Operation on "${mutation.collection}" was not applied (${result.result}).`,
-            // Prefer the pipeline's own classification when present; fall back
-            // to classifying the code so this stays correct if new codes appear.
-            retriable: result.rejection?.retriable ?? isRetriableRejection(code)
-          };
+        if (spec.also) {
+          mutations.push(...spec.also);
+        }
+        const prepared = [];
+        for (const mutation of mutations) {
+          const p = await prepareMutation(mutation, options?.scope);
+          if (!p.ok) {
+            return p.rejection;
+          }
+          prepared.push({ op: p.op, collection: mutation.collection });
+        }
+        const operations2 = [];
+        const records = [];
+        for (const { op, collection } of prepared) {
+          const result = await commitOperation(op, collection);
+          if (!result.ok) {
+            return {
+              ok: false,
+              code: result.code,
+              message: result.message,
+              retriable: result.retriable
+            };
+          }
+          operations2.push(result.operation);
+          records.push(result.record);
         }
-        const record = await store.findRecord(mutation.collection, op.recordId);
-        return { ok: true, operation: op, record };
+        return { ok: true, idempotent: false, operations: operations2, records };
       });
     },
     async query(collection, options) {