mongoku 2.8.1 → 2.9.0

package/build/server/chunks/{servers.remote-ChLjCujn.js → servers.remote-W2x65uTK.js}

@@ -1,19 +1,20 @@
-import { H as get_request_store, w as with_request_store } from './url-hmE1zcJ6.js';
+import { T as get_request_store, w as with_request_store } from './root-otUAnOAR.js';
 import { p as private_env } from './shared-server-BmU87nph.js';
-import './utils2-kjxf7BZO.js';
-import { M as MUTATIVE_METHODS, v as stringify_remote_arg, c as create_remote_key, d as handle_error_and_jsonify } from './shared-BqTYMAzZ.js';
-import { e as error, H as HttpError, S as SvelteKitError } from './index-wpIsICWW.js';
+import './utils-BQzn9ikS.js';
+import { M as MUTATIVE_METHODS, y as stringify_remote_arg, n as noop, c as create_remote_key, z as unfriendly_hydratable, q as stringify, e as handle_error_and_jsonify } from './shared-DlqhoNLb.js';
+import { e as error, H as HttpError, S as SvelteKitError } from './index-NcxaM188.js';
 import { p as parseJSON, v as validateAggregationPipeline, i as isEmptyObject } from './jsonParser-C3QUcODD.js';
 import { J as JsonEncoder } from './JsonEncoder-Dgtqxb_U.js';
 import { l as logger } from './logger-PfH_grbh.js';
 import { g as getMongo } from './mongo-B92d7zNj.js';
+import { a as auditSchemaCompliance } from './schema-BZonjzNJ.js';
 import { ObjectId, ReadPreference } from 'mongodb';
 import { z } from 'zod';
 
-/** @import { RemoteInfo } from 'types' */
+/** @import { RemoteInternals } from 'types' */
 
-/** @type {RemoteInfo['type'][]} */
-const types = ['command', 'form', 'prerender', 'query', 'query_batch'];
+/** @type {RemoteInternals['type'][]} */
+const types = ['command', 'form', 'prerender', 'query', 'query_batch', 'query_live'];
 
 /**
  * @param {Record<string, any>} module
@@ -70,13 +71,24 @@ function create_validator(validate_or_fn, maybe_fn) {
     'Invalid validator passed to remote function. Expected "unchecked" or a Standard Schema (https://standardschema.dev)'
   );
 }
-async function get_response(info, arg, state, get_result) {
+async function get_response(internals, payload, state, get_result) {
   await 0;
-  const cache = get_cache(info, state);
-  return cache[stringify_remote_arg(arg, state.transport)] ??= get_result();
+  const cache = get_cache(internals, state);
+  const entry = cache[payload] ??= {
+    serialize: false,
+    data: get_result()
+  };
+  entry.serialize ||= !!state.is_in_universal_load;
+  if (state.is_in_render && internals.id) {
+    const remote_key = create_remote_key(internals.id, payload);
+    Promise.resolve(entry.data).then((value) => {
+      void unfriendly_hydratable(remote_key, () => stringify(value, state.transport));
+    }).catch(noop);
+  }
+  return entry.data;
 }
-async function run_remote_function(event, state, allow_cookies, get_input, fn) {
-  const store = {
+function derive_remote_function_event(event, state, allow_cookies) {
+  return {
     event: {
       ...event,
       setHeaders: () => {
@@ -109,14 +121,52 @@ async function run_remote_function(event, state, allow_cookies, get_input, fn) {
       is_in_remote_function: true
     }
   };
+}
+async function run_remote_function(event, state, allow_cookies, get_input, fn) {
+  const store = derive_remote_function_event(event, state, allow_cookies);
   const input = await with_request_store(store, get_input);
   return with_request_store(store, () => fn(input));
 }
-function get_cache(info, state = get_request_store().state) {
-  let cache = state.remote_data?.get(info);
+async function* run_remote_generator(event, state, allow_cookies, get_input, fn, name) {
+  const store = derive_remote_function_event(event, state, allow_cookies);
+  const input = await with_request_store(store, get_input);
+  const source = await with_request_store(store, () => fn(input));
+  const iterator = to_iterator(source, name);
+  let done = false;
+  try {
+    while (true) {
+      const result = await with_request_store(store, () => iterator.next());
+      if (result.done) {
+        done = true;
+        return result.value;
+      }
+      yield result.value;
+    }
+  } finally {
+    if (!done && typeof iterator.return === "function") {
+      await with_request_store(store, () => iterator.return?.(void 0));
+    }
+  }
+}
+function to_iterator(source, name) {
+  if ("next" in source && typeof source.next === "function") {
+    return source;
+  }
+  if (Symbol.asyncIterator in source && typeof source[Symbol.asyncIterator] === "function") {
+    return source[Symbol.asyncIterator]();
+  }
+  if (Symbol.iterator in source && typeof source[Symbol.iterator] === "function") {
+    return source[Symbol.iterator]();
+  }
+  throw new Error(
+    `query.live '${name}' must return an Iterator, Iterable, AsyncIterator or AsyncIterable`
+  );
+}
+function get_cache(internals, state = get_request_store().state) {
+  let cache = state.remote.data?.get(internals);
   if (cache === void 0) {
     cache = {};
-    (state.remote_data ??= /* @__PURE__ */ new Map()).set(info, cache);
+    (state.remote.data ??= /* @__PURE__ */ new Map()).set(internals, cache);
   }
   return cache;
 }
@@ -127,13 +177,18 @@ function command(validate_or_fn, maybe_fn) {
   const __ = { type: "command", id: "", name: "" };
   const wrapper = (arg) => {
     const { event, state } = get_request_store();
-    if (!state.allows_commands) {
-      const disallowed_method = !MUTATIVE_METHODS.includes(event.request.method);
+    if (!MUTATIVE_METHODS.includes(event.request.method)) {
+      throw new Error(
+        `Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) from a ${event.request.method} handler`
+      );
+    }
+    if (state.is_in_render) {
       throw new Error(
-        `Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) ${disallowed_method ? `from a ${event.request.method} handler or ` : ""}during server-side rendering`
+        `Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) during server-side rendering`
       );
     }
-    state.refreshes ??= {};
+    state.remote.refreshes ??= /* @__PURE__ */ new Map();
+    state.remote.reconnects ??= /* @__PURE__ */ new Map();
     const promise = Promise.resolve(
       run_remote_function(event, state, true, () => validate(arg), fn)
     );
@@ -155,26 +210,74 @@ function command(validate_or_fn, maybe_fn) {
 function query(validate_or_fn, maybe_fn) {
   const fn = maybe_fn ?? validate_or_fn;
   const validate = create_validator(validate_or_fn, maybe_fn);
-  const __ = { type: "query", id: "", name: "" };
+  const __ = {
+    type: "query",
+    id: "",
+    name: "",
+    validate,
+    bind(payload, validated_arg) {
+      const { event, state } = get_request_store();
+      return create_query_resource(
+        __,
+        payload,
+        state,
+        () => run_remote_function(event, state, false, () => validated_arg, fn)
+      );
+    }
+  };
   const wrapper = (arg) => {
     const { event, state } = get_request_store();
-    const get_remote_function_result = () => run_remote_function(event, state, false, () => validate(arg), fn);
-    const promise = get_response(__, arg, state, get_remote_function_result);
-    promise.catch(() => {
-    });
-    promise.set = (value) => update_refresh_value(get_refresh_context(__, "set", arg), value);
-    promise.refresh = () => {
-      const refresh_context = get_refresh_context(__, "refresh", arg);
-      const is_immediate_refresh = !refresh_context.cache[refresh_context.cache_key];
-      const value = is_immediate_refresh ? promise : get_remote_function_result();
-      return update_refresh_value(refresh_context, value, is_immediate_refresh);
-    };
-    promise.withOverride = () => {
-      throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
-    };
-    return (
-      /** @type {RemoteQuery<Output>} */
-      promise
+    const payload = stringify_remote_arg(arg, state.transport);
+    return create_query_resource(
+      __,
+      payload,
+      state,
+      () => run_remote_function(event, state, false, () => validate(arg), fn)
+    );
+  };
+  Object.defineProperty(wrapper, "__", { value: __ });
+  return wrapper;
+}
+// @__NO_SIDE_EFFECTS__
+function live(validate_or_fn, maybe_fn) {
+  const fn = maybe_fn ?? validate_or_fn;
+  const validate = create_validator(validate_or_fn, maybe_fn);
+  const run = (event, state, get_input) => run_remote_generator(event, state, false, get_input, fn, __.name);
+  const first_value = async (generator) => {
+    try {
+      const { value, done } = await generator.next();
+      if (done) {
+        throw new Error(`query.live '${__.name}' did not yield a value`);
+      }
+      return value;
+    } finally {
+      await generator.return(void 0);
+    }
+  };
+  const __ = {
+    type: "query_live",
+    id: "",
+    name: "",
+    run: (event, state, arg) => run(event, state, () => validate(arg)),
+    validate,
+    bind(payload, validated_arg) {
+      const { event, state } = get_request_store();
+      return create_live_query_resource(
+        __,
+        payload,
+        state,
+        () => first_value(run(event, state, () => validated_arg))
+      );
+    }
+  };
+  const wrapper = (arg) => {
+    const { event, state } = get_request_store();
+    const payload = stringify_remote_arg(arg, state.transport);
+    return create_live_query_resource(
+      __,
+      payload,
+      state,
+      () => first_value(run(event, state, () => validate(arg)))
     );
   };
   Object.defineProperty(wrapper, "__", { value: __ });
@@ -184,10 +287,66 @@ function query(validate_or_fn, maybe_fn) {
 function batch(validate_or_fn, maybe_fn) {
   const fn = maybe_fn ?? validate_or_fn;
   const validate = create_validator(validate_or_fn, maybe_fn);
+  const enqueue = (payload, get_validated) => {
+    const { event, state } = get_request_store();
+    return new Promise((resolve, reject) => {
+      const batches = state.remote.batches ??= /** @type {NonNullable<typeof state.remote.batches>} */
+      /* @__PURE__ */ new Map();
+      let batched = batches.get(__.id);
+      if (!batched) {
+        batched = /* @__PURE__ */ new Map();
+        batches.set(__.id, batched);
+      }
+      const entry = batched.get(payload);
+      if (entry) {
+        entry.resolvers.push({ resolve, reject });
+        return;
+      }
+      batched.set(payload, {
+        get_validated,
+        resolvers: [{ resolve, reject }]
+      });
+      if (batched.size > 1) return;
+      setTimeout(async () => {
+        batches.delete(__.id);
+        const entries = Array.from(batched.values());
+        try {
+          return await run_remote_function(
+            event,
+            state,
+            false,
+            async () => Promise.all(entries.map((entry2) => entry2.get_validated())),
+            async (input) => {
+              const get_result = await fn(input);
+              for (let i = 0; i < entries.length; i++) {
+                try {
+                  const result = get_result(input[i], i);
+                  for (const resolver of entries[i].resolvers) {
+                    resolver.resolve(result);
+                  }
+                } catch (error2) {
+                  for (const resolver of entries[i].resolvers) {
+                    resolver.reject(error2);
+                  }
+                }
+              }
+            }
+          );
+        } catch (error2) {
+          for (const entry2 of batched.values()) {
+            for (const resolver of entry2.resolvers) {
+              resolver.reject(error2);
+            }
+          }
+        }
+      }, 0);
+    });
+  };
   const __ = {
     type: "query_batch",
     id: "",
     name: "",
+    validate,
     run: async (args, options) => {
       const { event, state } = get_request_store();
       return run_remote_function(
@@ -200,7 +359,8 @@ function batch(validate_or_fn, maybe_fn) {
           return Promise.all(
             input.map(async (arg, i) => {
               try {
-                return { type: "result", data: get_result(arg, i) };
+                const data = get_result(arg, i);
+                return { type: "result", data: stringify(data, state.transport) };
               } catch (error2) {
                 return {
                   type: "error",
@@ -212,69 +372,164 @@ function batch(validate_or_fn, maybe_fn) {
           );
         }
       );
+    },
+    bind(payload, validated_arg) {
+      const { state } = get_request_store();
+      return create_query_resource(__, payload, state, () => enqueue(payload, () => validated_arg));
     }
   };
-  let batching = { args: [], resolvers: [] };
   const wrapper = (arg) => {
-    const { event, state } = get_request_store();
-    const get_remote_function_result = () => {
-      return new Promise((resolve, reject) => {
-        batching.args.push(arg);
-        batching.resolvers.push({ resolve, reject });
-        if (batching.args.length > 1) return;
-        setTimeout(async () => {
-          const batched = batching;
-          batching = { args: [], resolvers: [] };
-          try {
-            return await run_remote_function(
-              event,
-              state,
-              false,
-              async () => Promise.all(batched.args.map(validate)),
-              async (input) => {
-                const get_result = await fn(input);
-                for (let i = 0; i < batched.resolvers.length; i++) {
-                  try {
-                    batched.resolvers[i].resolve(get_result(input[i], i));
-                  } catch (error2) {
-                    batched.resolvers[i].reject(error2);
-                  }
-                }
-              }
-            );
-          } catch (error2) {
-            for (const resolver of batched.resolvers) {
-              resolver.reject(error2);
-            }
-          }
-        }, 0);
-      });
-    };
-    const promise = get_response(__, arg, state, get_remote_function_result);
-    promise.catch(() => {
-    });
-    promise.set = (value) => update_refresh_value(get_refresh_context(__, "set", arg), value);
-    promise.refresh = () => {
-      const refresh_context = get_refresh_context(__, "refresh", arg);
-      const is_immediate_refresh = !refresh_context.cache[refresh_context.cache_key];
-      const value = is_immediate_refresh ? promise : get_remote_function_result();
-      return update_refresh_value(refresh_context, value, is_immediate_refresh);
-    };
-    promise.withOverride = () => {
-      throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
-    };
-    return (
-      /** @type {RemoteQuery<Output>} */
-      promise
+    const { state } = get_request_store();
+    const payload = stringify_remote_arg(arg, state.transport);
+    return create_query_resource(
+      __,
+      payload,
+      state,
+      () => (
+        // Collect all the calls to the same query in the same macrotask,
+        // then execute them as one backend request.
+        enqueue(payload, () => validate(arg))
+      )
     );
   };
   Object.defineProperty(wrapper, "__", { value: __ });
   return wrapper;
 }
+function create_query_resource(__, payload, state, fn) {
+  let promise = null;
+  const get_promise = () => {
+    return promise ??= get_response(__, payload, state, fn);
+  };
+  const populate_hydratable = () => {
+    void (__.id && state.is_in_render && get_promise());
+  };
+  return {
+    /** @type {Promise<any>['catch']} */
+    catch(onrejected) {
+      return get_promise().catch(onrejected);
+    },
+    get current() {
+      populate_hydratable();
+      return void 0;
+    },
+    get error() {
+      populate_hydratable();
+      return void 0;
+    },
+    /** @type {Promise<any>['finally']} */
+    finally(onfinally) {
+      return get_promise().finally(onfinally);
+    },
+    get loading() {
+      populate_hydratable();
+      return true;
+    },
+    get ready() {
+      populate_hydratable();
+      return false;
+    },
+    refresh() {
+      const { event } = get_request_store();
+      if (!event.isRemoteRequest) {
+        return Promise.resolve();
+      }
+      const refresh_context = get_refresh_context(__, "refresh", payload);
+      const is_immediate_refresh = !refresh_context.cache[refresh_context.payload];
+      const value = is_immediate_refresh ? get_promise() : fn();
+      return update_refresh_value(refresh_context, value, is_immediate_refresh);
+    },
+    run() {
+      if (!state.is_in_universal_load) {
+        throw new Error(
+          "On the server, .run() can only be called in universal `load` functions. Anywhere else, just await the query directly"
+        );
+      }
+      return get_response(__, payload, state, fn);
+    },
+    /** @param {any} value */
+    set(value) {
+      return update_refresh_value(get_refresh_context(__, "set", payload), value);
+    },
+    /** @type {Promise<any>['then']} */
+    then(onfulfilled, onrejected) {
+      return get_promise().then(onfulfilled, onrejected);
+    },
+    withOverride() {
+      throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
+    },
+    get [Symbol.toStringTag]() {
+      return "QueryResource";
+    }
+  };
+}
+function create_live_query_resource(__, payload, state, get_first_value) {
+  let promise = null;
+  const get_promise = () => {
+    return promise ??= get_response(__, payload, state, get_first_value);
+  };
+  const populate_hydratable = () => {
+    void (__.id && state.is_in_render && get_promise());
+  };
+  return {
+    /** @type {Promise<any>['catch']} */
+    catch(onrejected) {
+      return get_promise().catch(onrejected);
+    },
+    get current() {
+      populate_hydratable();
+      return void 0;
+    },
+    get error() {
+      populate_hydratable();
+      return void 0;
+    },
+    /** @type {Promise<any>['finally']} */
+    finally(onfinally) {
+      return get_promise().finally(onfinally);
+    },
+    get done() {
+      populate_hydratable();
+      return false;
+    },
+    get loading() {
+      populate_hydratable();
+      return true;
+    },
+    get ready() {
+      populate_hydratable();
+      return false;
+    },
+    get connected() {
+      populate_hydratable();
+      return false;
+    },
+    reconnect() {
+      const reconnects = state.remote.reconnects;
+      if (!reconnects) {
+        throw new Error(
+          `Cannot call reconnect on query.live '${__.name}' because it is not executed in the context of a command/form remote function`
+        );
+      }
+      reconnects.set(create_remote_key(__.id, payload), get_promise());
+      return Promise.resolve();
+    },
+    run() {
+      throw new Error("Cannot call .run() on a live query on the server");
+    },
+    /** @type {Promise<any>['then']} */
+    then(onfulfilled, onrejected) {
+      return get_promise().then(onfulfilled, onrejected);
+    },
+    get [Symbol.toStringTag]() {
+      return "LiveQueryResource";
+    }
+  };
+}
 Object.defineProperty(query, "batch", { value: batch, enumerable: true });
-function get_refresh_context(__, action, arg) {
+Object.defineProperty(query, "live", { value: live, enumerable: true });
+function get_refresh_context(__, action, payload) {
   const { state } = get_request_store();
-  const { refreshes } = state;
+  const { refreshes } = state.remote;
   if (!refreshes) {
     const name = __.type === "query_batch" ? `query.batch '${__.name}'` : `query '${__.name}'`;
     throw new Error(
@@ -282,20 +537,19 @@ function get_refresh_context(__, action, arg) {
     );
   }
   const cache = get_cache(__, state);
-  const cache_key = stringify_remote_arg(arg, state.transport);
-  const refreshes_key = create_remote_key(__.id, cache_key);
-  return { __, state, refreshes, refreshes_key, cache, cache_key };
+  const refreshes_key = create_remote_key(__.id, payload);
+  return { __, state, refreshes, refreshes_key, cache, payload };
 }
-function update_refresh_value({ __, refreshes, refreshes_key, cache, cache_key }, value, is_immediate_refresh = false) {
+function update_refresh_value({ __, refreshes, refreshes_key, cache, payload }, value, is_immediate_refresh = false) {
   const promise = Promise.resolve(value);
   if (!is_immediate_refresh) {
-    cache[cache_key] = promise;
+    cache[payload] = { serialize: true, data: promise };
   }
   if (__.id) {
-    refreshes[refreshes_key] = promise;
+    refreshes.set(refreshes_key, promise);
   }
-  return promise.then(() => {
-  });
+  promise.catch(noop);
+  return Promise.resolve();
 }
 
 const m = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
@@ -303,6 +557,9 @@ const m = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   get addServer() {
     return addServer;
   },
+  get auditSchema() {
+    return auditSchema;
+  },
   get countDocuments() {
     return countDocuments;
   },
@@ -1185,6 +1442,56 @@ const countDocumentsByTimeRange = query(
     }
   }
 );
+const auditSchema = query(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    collection: z.string(),
+    readPreferenceMode: z.string().optional(),
+    readPreferenceTags: z.string().optional()
+  }),
+  async ({ server, database, collection, readPreferenceMode, readPreferenceTags }) => {
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    try {
+      let readPreference;
+      if (readPreferenceMode) {
+        let tags;
+        if (readPreferenceTags) {
+          try {
+            const parsed = parseJSON(readPreferenceTags, { allowArray: true });
+            if (Array.isArray(parsed)) {
+              tags = parsed;
+            } else if (parsed && typeof parsed === "object") {
+              tags = [parsed];
+            }
+          } catch {
+          }
+        }
+        readPreference = tags ? new ReadPreference(
+          readPreferenceMode,
+          tags
+        ) : new ReadPreference(
+          readPreferenceMode
+        );
+      }
+      const result = await auditSchemaCompliance(client, database, collection, {
+        readPreference,
+        maxTimeMS: mongo.getQueryTimeout()
+      });
+      return {
+        data: JsonEncoder.encode(result),
+        error: null
+      };
+    } catch (err) {
+      logger.error("Error auditing schema compliance:", err);
+      return {
+        data: null,
+        error: `Failed to audit schema: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+  }
+);
 init_remote_functions(m, "src/api/servers.remote.ts", "xxtqbu");
 for (const [name, fn] of Object.entries(m)) {
   fn.__.id = "xxtqbu/" + name;
@@ -1192,4 +1499,4 @@ for (const [name, fn] of Object.entries(m)) {
 }
 
 export { countDocuments as c, deleteDocument as d, explainQuery as e, fetchMappedDocument as f, loadDocuments as l, m, updateDocument as u };
-//# sourceMappingURL=servers.remote-ChLjCujn.js.map
+//# sourceMappingURL=servers.remote-W2x65uTK.js.map