@scalar/cli 2.0.1 → 2.1.0

package/chunks/chunk-SHSHFGA7.js

@@ -0,0 +1,297 @@
+import { createRequire as $$cR } from "node:module"; const require = $$cR(import.meta.url);
+import {
+  getAuthData
+} from "./chunk-5BISXQX4.js";
+import {
+  config
+} from "./chunk-OAXFCOJV.js";
+import {
+  objectSchema,
+  schemaModel
+} from "./chunk-ISGLWBXZ.js";
+import {
+  external_exports
+} from "./chunk-H2WRMLYY.js";
+
+// ../../packages/mongobase-client/dist/auth/tokens.js
+var tokenResponseSchema = external_exports.object({
+  accessToken: external_exports.string(),
+  refreshToken: external_exports.string()
+});
+
+// ../../packages/mongobase-client/dist/auth/utility.js
+var ErrorCode;
+(function(ErrorCode2) {
+  ErrorCode2["AuthFail"] = "auth-fail";
+})(ErrorCode || (ErrorCode = {}));
+
+// ../../packages/mongobase-client/dist/database/access.js
+var primitiveSchema = external_exports.union([
+  external_exports.string(),
+  external_exports.number(),
+  external_exports.boolean(),
+  external_exports.null()
+]);
+var $filterSchema = external_exports.object({
+  $in: external_exports.string().array().optional(),
+  $nin: external_exports.string().array().optional(),
+  $eq: primitiveSchema.optional(),
+  $ne: primitiveSchema.optional(),
+  $lt: external_exports.number().optional(),
+  $gt: external_exports.number().optional(),
+  $gte: external_exports.number().optional(),
+  $lte: external_exports.number().optional(),
+  $or: external_exports.lazy(() => $filterSchema.array()).optional()
+});
+var querySchema = external_exports.record(external_exports.string(), external_exports.union([primitiveSchema, $filterSchema]));
+var getRecordRequestSchema = external_exports.object({
+  collectionPath: external_exports.string(),
+  query: querySchema
+});
+var addRecordRequestSchema = external_exports.object({
+  collectionPath: external_exports.string(),
+  data: objectSchema
+});
+var addMultipleRecordsRequestSchema = external_exports.object({
+  collectionPath: external_exports.string(),
+  data: objectSchema.array()
+});
+var updateRecordRequestSchema = external_exports.object({
+  collectionPath: external_exports.string(),
+  data: objectSchema,
+  query: querySchema
+});
+var deleteRecordRequestSchema = external_exports.object({
+  collectionPath: external_exports.string(),
+  query: querySchema
+});
+var dropCollectionRequestSchema = external_exports.object({
+  collectionPath: external_exports.string()
+});
+function formatResponse(response, schema) {
+  return {
+    status: response.status,
+    data: schemaModel(response.data, schema),
+    error: false
+  };
+}
+var statusMessages = {
+  401: "Unauthorized. Please check that an access token was provided to the instance. "
+};
+function formatError(error, message) {
+  return {
+    status: error.status ?? 500,
+    message: statusMessages[error.response?.status] ?? error.message ?? message,
+    error: true,
+    originalError: error
+  };
+}
+var addResponseSchema = external_exports.object({
+  insertedId: external_exports.string()
+});
+var addMultiResponseSchema = external_exports.object({
+  insertedCount: external_exports.number(),
+  insertedIds: external_exports.preprocess((s) => Array.isArray(s) ? s : Object.values(s), external_exports.string().array())
+});
+var updateResponseSchema = external_exports.object({
+  matchedCount: external_exports.number(),
+  modifiedCount: external_exports.number(),
+  upsertedCount: external_exports.number(),
+  upsertedId: external_exports.string().nullable()
+});
+var deletedResponseSchema = external_exports.object({
+  deletedCount: external_exports.number()
+});
+function createAccess(baseURL) {
+  const state = {
+    accessToken: ""
+  };
+  function makeRequest(options) {
+    return fetch(`${baseURL}${options.url}`, {
+      method: options.method,
+      headers: {
+        ...options.headers,
+        // An empty bearer token is always rejected — omit the header so the
+        // server returns a clean 401 instead of parsing a malformed value
+        ...state.accessToken ? { Authorization: `Bearer ${state.accessToken}` } : {},
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(options.data)
+    }).then(async (res) => {
+      if (!res.ok) {
+        return formatError({ status: res.status, message: await res.text() }, "Unknown Error");
+      }
+      return formatResponse({ data: await res.json(), status: res.status }, options.schema);
+    }).catch((err) => formatError(err));
+  }
+  function get({ collectionPath, query, schema, type }) {
+    const data = schemaModel({ collectionPath, query }, getRecordRequestSchema);
+    return makeRequest({
+      url: `/database/get-${type}`,
+      method: "POST",
+      data,
+      schema
+    });
+  }
+  function addOne({ collectionPath, data, schema, responseSchema }) {
+    const sanitizedData = schemaModel({ collectionPath, data: schemaModel(data, schema) }, addRecordRequestSchema);
+    return makeRequest({
+      url: "/database/add-one",
+      method: "POST",
+      data: sanitizedData,
+      schema: responseSchema
+    });
+  }
+  function addMultiple({ collectionPath, data, schema, responseSchema }) {
+    const sanitizedData = schemaModel({ collectionPath, data: schemaModel(data, schema) }, addMultipleRecordsRequestSchema);
+    return makeRequest({
+      url: "/database/add-many",
+      method: "POST",
+      data: sanitizedData,
+      schema: responseSchema
+    });
+  }
+  function remove({ collectionPath, query, type }) {
+    const data = schemaModel({ collectionPath, query }, deleteRecordRequestSchema);
+    return makeRequest({
+      url: `/database/delete-${type}`,
+      method: "POST",
+      data,
+      schema: deletedResponseSchema
+    });
+  }
+  function update({ collectionPath, data, query, schema }) {
+    const updateData = schemaModel({
+      collectionPath,
+      query,
+      data: schemaModel(data, schema)
+    }, updateRecordRequestSchema);
+    return makeRequest({
+      url: "/database/update-one",
+      method: "POST",
+      data: updateData,
+      schema: updateResponseSchema
+    });
+  }
+  function dropCollection({ collectionPath }) {
+    const data = schemaModel({ collectionPath }, dropCollectionRequestSchema);
+    return makeRequest({
+      url: "/database/drop-collection",
+      method: "POST",
+      data,
+      schema: external_exports.any()
+    });
+  }
+  return {
+    /** Update the access token */
+    updateAccessToken(accessToken) {
+      state.accessToken = accessToken;
+    },
+    async checkHealth(url) {
+      if (!state.accessToken) {
+        return {
+          status: 511,
+          message: "No Access Token",
+          error: true,
+          originalError: null
+        };
+      }
+      return await makeRequest({
+        url,
+        method: "GET",
+        schema: external_exports.any()
+      });
+    },
+    /** Get a single record */
+    getOne(options) {
+      return get({ ...options, type: "one" });
+    },
+    /** Get multiple records */
+    getMany(options) {
+      return get({ ...options, type: "many" });
+    },
+    /** Add a single record */
+    addOne(options) {
+      return addOne({ ...options, responseSchema: addResponseSchema });
+    },
+    /** Add multiple records */
+    addMany(options) {
+      return addMultiple({ ...options, responseSchema: addMultiResponseSchema });
+    },
+    updateOne(options) {
+      return update({ ...options });
+    },
+    /** Delete a single record */
+    deleteOne(options) {
+      return remove({ ...options, type: "one" });
+    },
+    /** Delete multiple records */
+    deleteMany(options) {
+      return remove({ ...options, type: "many" });
+    },
+    dropCollection
+  };
+}
+
+// ../../packages/mongobase-client/dist/database/offline.js
+var DiffOp;
+(function(DiffOp2) {
+  DiffOp2["Remove"] = "remove";
+  DiffOp2["Replace"] = "replace";
+  DiffOp2["Add"] = "add";
+})(DiffOp || (DiffOp = {}));
+var diffRecordSchema = external_exports.object({
+  op: external_exports.enum(DiffOp),
+  path: external_exports.union([external_exports.string(), external_exports.number()]).array(),
+  value: external_exports.any()
+});
+var MutationOp;
+(function(MutationOp2) {
+  MutationOp2["Add"] = "add";
+  MutationOp2["Update"] = "update";
+  MutationOp2["Delete"] = "delete";
+})(MutationOp || (MutationOp = {}));
+var collectionChangeRecordSchema = external_exports.record(external_exports.string(), external_exports.object({
+  action: external_exports.enum(MutationOp),
+  value: external_exports.any()
+}));
+var changelogSchema = external_exports.record(external_exports.string(), collectionChangeRecordSchema);
+
+// ../../packages/mongobase-client/dist/database/socket.js
+var SubscriptionTypes;
+(function(SubscriptionTypes2) {
+  SubscriptionTypes2["Collection"] = "collection";
+  SubscriptionTypes2["Document"] = "document";
+})(SubscriptionTypes || (SubscriptionTypes = {}));
+var MAX_RECONNECT_INTERVAL = 60 * 1e3;
+
+// ../../packages/mongobase-client/dist/database/subscribe.js
+var SubscriptionAction;
+(function(SubscriptionAction2) {
+  SubscriptionAction2["Add"] = "insert";
+  SubscriptionAction2["Update"] = "update";
+  SubscriptionAction2["Remove"] = "delete";
+})(SubscriptionAction || (SubscriptionAction = {}));
+
+// ../../packages/mongobase-client/dist/database/index.js
+function initDatabase(baseUrl) {
+  if (!baseUrl)
+    throw new Error("Invalid URL provided to initDatabase");
+  return createAccess(baseUrl);
+}
+
+// src/helpers/database.ts
+var getDatabaseClient = async () => {
+  const client = initDatabase(`${config.services.api}/rtdb`);
+  const auth = await getAuthData();
+  auth.addEventListener((state) => {
+    Object.assign(auth, state);
+    client.updateAccessToken(state.accessToken);
+  });
+  client.updateAccessToken(auth.accessToken);
+  return client;
+};
+
+export {
+  getDatabaseClient
+};