mongoku 2.0.4 → 2.1.1

package/build/server/chunks/servers.remote-C2HuT43p.js

@@ -0,0 +1,690 @@
+import { g as get_request_store, w as with_request_store } from './event-DVH-6ISX.js';
+import './utils-kjxf7BZO.js';
+import { c as create_remote_cache_key, s as stringify_remote_arg } from './shared-Buki-xt5.js';
+import { e as error } from './index-Djsj11qr.js';
+import { p as parseJSON, v as validateAggregationPipeline, i as isEmptyObject } from './jsonParser-CraFXJs8.js';
+import { J as JsonEncoder } from './JsonEncoder-jJ2OBaud.js';
+import { g as getMongo } from './mongo-BogiTfnG.js';
+import { l as logger } from './logger-D71iWOkl.js';
+import { ObjectId } from 'mongodb';
+import { z } from 'zod';
+
+/** @import { RemoteInfo } from 'types' */
+
+/** @type {RemoteInfo['type'][]} */
+const types = ['command', 'form', 'prerender', 'query', 'query_batch'];
+
+/**
+ * @param {Record<string, any>} module
+ * @param {string} file
+ * @param {string} hash
+ */
+function init_remote_functions(module, file, hash) {
+	if (module.default) {
+		throw new Error(
+			`Cannot export \`default\` from a remote module (${file}) — please use named exports instead`
+		);
+	}
+
+	for (const [name, fn] of Object.entries(module)) {
+		if (!types.includes(fn?.__?.type)) {
+			throw new Error(
+				`\`${name}\` exported from ${file} is invalid — all exports from this file must be remote functions`
+			);
+		}
+
+		fn.__.id = `${hash}/${name}`;
+		fn.__.name = name;
+	}
+}
+
+function create_validator(validate_or_fn, maybe_fn) {
+  if (!maybe_fn) {
+    return (arg) => {
+      if (arg !== void 0) {
+        error(400, "Bad Request");
+      }
+    };
+  }
+  if (validate_or_fn === "unchecked") {
+    return (arg) => arg;
+  }
+  if ("~standard" in validate_or_fn) {
+    return async (arg) => {
+      const { event, state } = get_request_store();
+      const validate = validate_or_fn["~standard"].validate;
+      const result = await validate(arg);
+      if (result.issues) {
+        error(
+          400,
+          await state.handleValidationError({
+            issues: result.issues,
+            event
+          })
+        );
+      }
+      return result.value;
+    };
+  }
+  throw new Error(
+    'Invalid validator passed to remote function. Expected "unchecked" or a Standard Schema (https://standardschema.dev)'
+  );
+}
+async function get_response(info, arg, state, get_result) {
+  await 0;
+  const cache = get_cache(info, state);
+  return cache[stringify_remote_arg(arg, state.transport)] ??= get_result();
+}
+async function run_remote_function(event, state, allow_cookies, arg, validate, fn) {
+  const store = {
+    event: {
+      ...event,
+      setHeaders: () => {
+        throw new Error("setHeaders is not allowed in remote functions");
+      },
+      cookies: {
+        ...event.cookies,
+        set: (name, value, opts) => {
+          if (!allow_cookies) {
+            throw new Error("Cannot set cookies in `query` or `prerender` functions");
+          }
+          if (opts.path && !opts.path.startsWith("/")) {
+            throw new Error("Cookies set in remote functions must have an absolute path");
+          }
+          return event.cookies.set(name, value, opts);
+        },
+        delete: (name, opts) => {
+          if (!allow_cookies) {
+            throw new Error("Cannot delete cookies in `query` or `prerender` functions");
+          }
+          if (opts.path && !opts.path.startsWith("/")) {
+            throw new Error("Cookies deleted in remote functions must have an absolute path");
+          }
+          return event.cookies.delete(name, opts);
+        }
+      }
+    },
+    state: {
+      ...state,
+      is_in_remote_function: true
+    }
+  };
+  const validated = await with_request_store(store, () => validate(arg));
+  return with_request_store(store, () => fn(validated));
+}
+function get_cache(info, state = get_request_store().state) {
+  let cache = state.remote_data?.get(info);
+  if (cache === void 0) {
+    cache = {};
+    (state.remote_data ??= /* @__PURE__ */ new Map()).set(info, cache);
+  }
+  return cache;
+}
+// @__NO_SIDE_EFFECTS__
+function command(validate_or_fn, maybe_fn) {
+  const fn = maybe_fn ?? validate_or_fn;
+  const validate = create_validator(validate_or_fn, maybe_fn);
+  const __ = { type: "command", id: "", name: "" };
+  const wrapper = (arg) => {
+    const { event, state } = get_request_store();
+    if (state.is_endpoint_request) {
+      if (!["POST", "PUT", "PATCH", "DELETE"].includes(event.request.method)) {
+        throw new Error(
+          `Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) from a ${event.request.method} handler`
+        );
+      }
+    } else if (!event.isRemoteRequest) {
+      throw new Error(
+        `Cannot call a command (\`${__.name}(${maybe_fn ? "..." : ""})\`) during server-side rendering`
+      );
+    }
+    state.refreshes ??= {};
+    const promise = Promise.resolve(run_remote_function(event, state, true, arg, validate, fn));
+    promise.updates = () => {
+      throw new Error(`Cannot call '${__.name}(...).updates(...)' on the server`);
+    };
+    return (
+      /** @type {ReturnType<RemoteCommand<Input, Output>>} */
+      promise
+    );
+  };
+  Object.defineProperty(wrapper, "__", { value: __ });
+  Object.defineProperty(wrapper, "pending", {
+    get: () => 0
+  });
+  return wrapper;
+}
+// @__NO_SIDE_EFFECTS__
+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 wrapper = (arg) => {
+    const { event, state } = get_request_store();
+    const promise = get_response(
+      __,
+      arg,
+      state,
+      () => run_remote_function(event, state, false, arg, validate, fn)
+    );
+    promise.catch(() => {
+    });
+    promise.set = (value) => {
+      const { state: state2 } = get_request_store();
+      const refreshes = state2.refreshes;
+      if (!refreshes) {
+        throw new Error(
+          `Cannot call set on query '${__.name}' because it is not executed in the context of a command/form remote function`
+        );
+      }
+      if (__.id) {
+        const cache = get_cache(__, state2);
+        const key = stringify_remote_arg(arg, state2.transport);
+        refreshes[create_remote_cache_key(__.id, key)] = cache[key] = Promise.resolve(value);
+      }
+    };
+    promise.refresh = () => {
+      const { state: state2 } = get_request_store();
+      const refreshes = state2.refreshes;
+      if (!refreshes) {
+        throw new Error(
+          `Cannot call refresh on query '${__.name}' because it is not executed in the context of a command/form remote function`
+        );
+      }
+      const cache_key = create_remote_cache_key(__.id, stringify_remote_arg(arg, state2.transport));
+      refreshes[cache_key] = promise;
+      return promise.then(() => {
+      });
+    };
+    promise.withOverride = () => {
+      throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
+    };
+    return (
+      /** @type {RemoteQuery<Output>} */
+      promise
+    );
+  };
+  Object.defineProperty(wrapper, "__", { value: __ });
+  return wrapper;
+}
+// @__NO_SIDE_EFFECTS__
+function batch(validate_or_fn, maybe_fn) {
+  const fn = maybe_fn ?? validate_or_fn;
+  const validate = create_validator(validate_or_fn, maybe_fn);
+  const __ = {
+    type: "query_batch",
+    id: "",
+    name: "",
+    run: (args) => {
+      const { event, state } = get_request_store();
+      return run_remote_function(
+        event,
+        state,
+        false,
+        args,
+        (array) => Promise.all(array.map(validate)),
+        fn
+      );
+    }
+  };
+  let batching = { args: [], resolvers: [] };
+  const wrapper = (arg) => {
+    const { event, state } = get_request_store();
+    const promise = get_response(__, arg, state, () => {
+      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 {
+            const get_result = await run_remote_function(
+              event,
+              state,
+              false,
+              batched.args,
+              (array) => Promise.all(array.map(validate)),
+              fn
+            );
+            for (let i = 0; i < batched.resolvers.length; i++) {
+              try {
+                batched.resolvers[i].resolve(get_result(batched.args[i], i));
+              } catch (error2) {
+                batched.resolvers[i].reject(error2);
+              }
+            }
+          } catch (error2) {
+            for (const resolver of batched.resolvers) {
+              resolver.reject(error2);
+            }
+          }
+        }, 0);
+      });
+    });
+    promise.catch(() => {
+    });
+    promise.refresh = async () => {
+      const { state: state2 } = get_request_store();
+      const refreshes = state2.refreshes;
+      if (!refreshes) {
+        throw new Error(
+          `Cannot call refresh on query.batch '${__.name}' because it is not executed in the context of a command/form remote function`
+        );
+      }
+      const cache_key = create_remote_cache_key(__.id, stringify_remote_arg(arg, state2.transport));
+      refreshes[cache_key] = await /** @type {Promise<any>} */
+      promise;
+    };
+    promise.withOverride = () => {
+      throw new Error(`Cannot call '${__.name}.withOverride()' on the server`);
+    };
+    return (
+      /** @type {RemoteQuery<Output>} */
+      promise
+    );
+  };
+  Object.defineProperty(wrapper, "__", { value: __ });
+  return wrapper;
+}
+Object.defineProperty(query, "batch", { value: batch, enumerable: true });
+
+const m = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  get addServer() {
+    return addServer;
+  },
+  get deleteDocument() {
+    return deleteDocument;
+  },
+  get dropCollection() {
+    return dropCollection;
+  },
+  get dropIndex() {
+    return dropIndex;
+  },
+  get fetchMappedDocument() {
+    return fetchMappedDocument;
+  },
+  get hideIndex() {
+    return hideIndex;
+  },
+  get insertDocument() {
+    return insertDocument;
+  },
+  get loadDocuments() {
+    return loadDocuments;
+  },
+  get removeServer() {
+    return removeServer;
+  },
+  get retryConnection() {
+    return retryConnection;
+  },
+  get unhideIndex() {
+    return unhideIndex;
+  },
+  get updateDocument() {
+    return updateDocument;
+  },
+  get updateMany() {
+    return updateMany;
+  }
+}, Symbol.toStringTag, { value: "Module" }));
+function checkReadOnly() {
+  if (process.env.MONGOKU_READ_ONLY_MODE === "true") {
+    error(403, "Read-only mode is enabled");
+  }
+}
+const addServer = command(
+  z.object({
+    url: z.string()
+  }),
+  async ({ url }) => {
+    logger.log("addServer called with payload:", { url });
+    const mongo = await getMongo();
+    await mongo.addServer(url);
+    return { ok: true };
+  }
+);
+const removeServer = command(z.string(), async (serverName) => {
+  logger.log("removeServer called with payload:", { serverName });
+  const mongo = await getMongo();
+  await mongo.removeServer(serverName);
+  return { ok: true };
+});
+const updateDocument = command(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    collection: z.string(),
+    document: z.string(),
+    value: z.unknown(),
+    partial: z.boolean().optional().default(false),
+    upsert: z.boolean().optional().default(false)
+  }),
+  async ({ server, database, collection, document, value, partial, upsert }) => {
+    logger.log("updateDocument called with payload:", { server, database, collection, document, partial, upsert });
+    checkReadOnly();
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    const coll = client.db(database).collection(collection);
+    const newValue = JsonEncoder.decode(value);
+    const _id = /^[0-9a-fA-F]{24}$/.test(document) ? new ObjectId(document) : document;
+    if (partial) {
+      await coll.updateOne(
+        {
+          _id
+        },
+        { $set: newValue },
+        { upsert }
+      );
+    } else {
+      await coll.replaceOne(
+        {
+          _id
+        },
+        JsonEncoder.decode(newValue),
+        { upsert }
+      );
+    }
+    if (collection === "mongoku.mappings") {
+      client.clearMappingsCache(database, document);
+    }
+    return {
+      ok: true,
+      update: JsonEncoder.encode(newValue)
+    };
+  }
+);
+const insertDocument = command(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    collection: z.string(),
+    document: z.string(),
+    value: z.unknown()
+  }),
+  async ({ server, database, collection, document, value }) => {
+    logger.log("insertDocument called with payload:", { server, database, collection, document });
+    checkReadOnly();
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    const coll = client.db(database).collection(collection);
+    const newValue = JsonEncoder.decode(value);
+    const _id = /^[0-9a-fA-F]{24}$/.test(document) ? new ObjectId(document) : document;
+    newValue._id = _id;
+    await coll.insertOne(newValue);
+    if (collection === "mongoku.mappings") {
+      client.clearMappingsCache(database, document);
+    }
+    return {
+      ok: true,
+      insert: JsonEncoder.encode(newValue)
+    };
+  }
+);
+const deleteDocument = command(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    collection: z.string(),
+    document: z.string()
+  }),
+  async ({ server, database, collection, document }) => {
+    logger.log("deleteDocument called with payload:", { server, database, collection, document });
+    checkReadOnly();
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    await client.db(database).collection(collection).deleteOne({
+      _id: new ObjectId(document)
+    });
+    if (collection === "mongoku.mappings") {
+      client.clearMappingsCache(database, document);
+    }
+    return {
+      ok: true
+    };
+  }
+);
+const updateMany = command(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    collection: z.string(),
+    filter: z.string(),
+    update: z.string()
+  }),
+  async ({ server, database, collection, filter, update }) => {
+    logger.log("updateMany called with payload:", { server, database, collection, filter, update });
+    checkReadOnly();
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    const coll = client.db(database).collection(collection);
+    const filterDoc = JsonEncoder.decode(parseJSON(filter));
+    const updateDoc = JsonEncoder.decode(parseJSON(update));
+    const result = await coll.updateMany(filterDoc, updateDoc);
+    return {
+      ok: true,
+      matchedCount: result.matchedCount,
+      modifiedCount: result.modifiedCount
+    };
+  }
+);
+const hideIndex = command(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    collection: z.string(),
+    index: z.string()
+  }),
+  async ({ server, database, collection, index }) => {
+    logger.log("hideIndex called with payload:", { server, database, collection, index });
+    checkReadOnly();
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    await client.db(database).command({
+      collMod: collection,
+      index: {
+        name: index,
+        hidden: true
+      }
+    });
+    return {
+      ok: true
+    };
+  }
+);
+const unhideIndex = command(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    collection: z.string(),
+    index: z.string()
+  }),
+  async ({ server, database, collection, index }) => {
+    logger.log("unhideIndex called with payload:", { server, database, collection, index });
+    checkReadOnly();
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    await client.db(database).command({
+      collMod: collection,
+      index: {
+        name: index,
+        hidden: false
+      }
+    });
+    return {
+      ok: true
+    };
+  }
+);
+const dropIndex = command(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    collection: z.string(),
+    index: z.string()
+  }),
+  async ({ server, database, collection, index }) => {
+    logger.log("dropIndex called with payload:", { server, database, collection, index });
+    checkReadOnly();
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    await client.db(database).command({
+      dropIndexes: collection,
+      index
+    });
+    return {
+      ok: true
+    };
+  }
+);
+const dropCollection = command(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    collection: z.string()
+  }),
+  async ({ server, database, collection }) => {
+    logger.log("dropCollection called with payload:", { server, database, collection });
+    checkReadOnly();
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    const db = client.db(database);
+    await db.dropCollection(collection);
+    return {
+      ok: true
+    };
+  }
+);
+const retryConnection = command(z.string(), async (serverName) => {
+  logger.log("retryConnection called with payload:", { serverName });
+  const mongo = await getMongo();
+  await mongo.reconnectClient(serverName);
+  return { ok: true };
+});
+const loadDocuments = query(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    collection: z.string(),
+    query: z.string().default("{}"),
+    sort: z.string().default("{}"),
+    project: z.string().default("{}"),
+    skip: z.number().int().default(0),
+    limit: z.number().int().default(20)
+  }),
+  async ({ server, database, collection, query: queryStr, sort, project, skip, limit }) => {
+    let queryDoc;
+    try {
+      queryDoc = parseJSON(queryStr, { allowArray: true });
+    } catch (err) {
+      error(400, `Invalid query: ${err}`);
+    }
+    try {
+      parseJSON(sort);
+    } catch (err) {
+      error(400, `Invalid sort: ${err}`);
+    }
+    try {
+      parseJSON(project);
+    } catch (err) {
+      error(400, `Invalid project: ${err}`);
+    }
+    const sortDoc = parseJSON(sort);
+    const projectDoc = parseJSON(project);
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    const coll = client.db(database).collection(collection);
+    if (Array.isArray(queryDoc)) {
+      try {
+        validateAggregationPipeline(queryDoc);
+      } catch (err) {
+        error(400, `Invalid aggregation pipeline: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      const pipeline = JsonEncoder.decode(queryDoc);
+      try {
+        const results = await coll.aggregate(
+          [
+            ...pipeline,
+            ...isEmptyObject(projectDoc) ? [] : [{ $project: projectDoc }],
+            ...isEmptyObject(sortDoc) ? [] : [{ $sort: sortDoc }],
+            { $limit: limit },
+            { $skip: skip }
+          ],
+          {
+            maxTimeMS: mongo.getQueryTimeout()
+          }
+        ).map((obj) => JsonEncoder.encode(obj)).toArray();
+        return {
+          data: results,
+          error: null,
+          isAggregation: true
+        };
+      } catch (err) {
+        logger.error("Error executing aggregation:", err);
+        error(500, `Failed to execute aggregation: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    try {
+      const results = await coll.find(JsonEncoder.decode(queryDoc), { maxTimeMS: mongo.getQueryTimeout() }).project(projectDoc).sort(JsonEncoder.decode(sortDoc)).limit(limit).skip(skip).map((obj) => JsonEncoder.encode(obj)).toArray();
+      return {
+        data: results,
+        error: null,
+        isAggregation: false
+      };
+    } catch (err) {
+      logger.error("Error fetching query results:", err);
+      error(500, `Failed to fetch query results: ${err instanceof Error ? err.message : String(err)}`);
+    }
+  }
+);
+const fetchMappedDocument = query(
+  z.object({
+    server: z.string(),
+    database: z.string(),
+    mappings: z.array(
+      z.object({
+        collection: z.string(),
+        on: z.string()
+      })
+    ),
+    value: z.unknown()
+  }),
+  async ({ server, database, mappings, value }) => {
+    const mongo = await getMongo();
+    const client = mongo.getClient(server);
+    const decodedValue = JsonEncoder.decode(value);
+    for (const mapping of mappings) {
+      try {
+        const coll = client.db(database).collection(mapping.collection);
+        const query2 = { [mapping.on]: decodedValue };
+        const document = await coll.findOne(query2, { maxTimeMS: mongo.getQueryTimeout() });
+        if (document) {
+          return {
+            data: JsonEncoder.encode(document),
+            collection: mapping.collection,
+            error: null
+          };
+        }
+      } catch (err) {
+        logger.error(`Error fetching mapped document from ${mapping.collection}.${mapping.on}:`, err);
+        continue;
+      }
+    }
+    return {
+      data: null,
+      collection: null,
+      error: "Document not found in any mapped collection"
+    };
+  }
+);
+init_remote_functions(m, "src/api/servers.remote.ts", "xxtqbu");
+for (const [name, fn] of Object.entries(m)) {
+  fn.__.id = "xxtqbu/" + name;
+  fn.__.name = name;
+}
+
+export { deleteDocument as d, fetchMappedDocument as f, m, updateDocument as u };
+//# sourceMappingURL=servers.remote-C2HuT43p.js.map