@sfxcode/nuxt-mongocamp-server 1.4.4 → 1.5.0

package/dist/runtime/composables/mongocampApi.js

@@ -1,43 +1,10 @@
-import { AdminApi } from "../api/apis/AdminApi.js";
-import { ApplicationApi } from "../api/apis/ApplicationApi.js";
-import { AuthApi } from "../api/apis/AuthApi.js";
-import { BucketApi } from "../api/apis/BucketApi.js";
-import { CollectionApi } from "../api/apis/CollectionApi.js";
-import { DatabaseApi } from "../api/apis/DatabaseApi.js";
-import { DocumentApi } from "../api/apis/DocumentApi.js";
-import { FileApi } from "../api/apis/FileApi.js";
-import { IndexApi } from "../api/apis/IndexApi.js";
-import { InformationApi } from "../api/apis/InformationApi.js";
-import { JobsApi } from "../api/apis/JobsApi.js";
 import { Configuration } from "../api/index.js";
+import { createMongocampApis } from "../utils/createMongocampApis.js";
 import { useMongocampUrl } from "./mongocampUrl.js";
 import { useMongocampStorage } from "./mongocampStorage.js";
 export function useMongocampApi() {
   const url = useMongocampUrl();
-  const token = useMongocampStorage();
-  const configuration = new Configuration({ basePath: url, accessToken: token.value.token });
-  const adminApi = new AdminApi(configuration);
-  const applicationApi = new ApplicationApi(configuration);
-  const authApi = new AuthApi(configuration);
-  const bucketApi = new BucketApi(configuration);
-  const collectionApi = new CollectionApi(configuration);
-  const databaseApi = new DatabaseApi(configuration);
-  const documentApi = new DocumentApi(configuration);
-  const fileApi = new FileApi(configuration);
-  const indexApi = new IndexApi(configuration);
-  const informationApi = new InformationApi(configuration);
-  const jobApi = new JobsApi(configuration);
-  return {
-    adminApi,
-    applicationApi,
-    authApi,
-    bucketApi,
-    collectionApi,
-    databaseApi,
-    documentApi,
-    fileApi,
-    indexApi,
-    informationApi,
-    jobApi
-  };
+  const state = useMongocampStorage();
+  const configuration = new Configuration({ basePath: url, accessToken: () => state.value.token });
+  return createMongocampApis(configuration);
 }

package/dist/runtime/composables/mongocampApiAdmin.d.ts

@@ -0,0 +1,15 @@
+import type { PasswordUpdateRequest, Role, UpdateRoleRequest, UserInformation } from '../api/index.js';
+export declare function useMongocampApiAdmin(): {
+    listUsers: (filter?: string, rowsPerPage?: number, page?: number) => Promise<import("../api/index.js").UserProfile[]>;
+    getUser: (userId: string) => Promise<import("../api/index.js").UserProfile>;
+    addUser: (userInformation: UserInformation) => Promise<import("../api/index.js").UserProfile>;
+    deleteUser: (userId: string) => Promise<import("../api/index.js").JsonValueBoolean>;
+    updatePasswordForUser: (userId: string, passwordUpdateRequest: PasswordUpdateRequest) => Promise<import("../api/index.js").JsonValueBoolean>;
+    updateRolesForUser: (userId: string, roles: string[]) => Promise<import("../api/index.js").UserProfile>;
+    generateNewApiKeyForUser: (userId: string) => Promise<import("../api/index.js").JsonValueString>;
+    listRoles: (filter?: string, rowsPerPage?: number, page?: number) => Promise<Role[]>;
+    getRole: (roleName: string) => Promise<Role>;
+    addRole: (role: Role) => Promise<Role>;
+    updateRole: (roleName: string, updateRoleRequest: UpdateRoleRequest) => Promise<Role>;
+    deleteRole: (roleName: string) => Promise<import("../api/index.js").JsonValueBoolean>;
+};

package/dist/runtime/composables/mongocampApiAdmin.js

@@ -0,0 +1,41 @@
+import { useMongocampApi } from "./mongocampApi.js";
+export function useMongocampApiAdmin() {
+  const { adminApi } = useMongocampApi();
+  function listUsers(filter, rowsPerPage, page) {
+    return adminApi.listUsers({ filter, rowsPerPage, page });
+  }
+  function getUser(userId) {
+    return adminApi.getUser({ userId });
+  }
+  function addUser(userInformation) {
+    return adminApi.addUser({ userInformation });
+  }
+  function deleteUser(userId) {
+    return adminApi.deleteUser({ userId });
+  }
+  function updatePasswordForUser(userId, passwordUpdateRequest) {
+    return adminApi.updatePasswordForUser({ userId, passwordUpdateRequest });
+  }
+  function updateRolesForUser(userId, roles) {
+    return adminApi.updateRolesForUser({ userId, requestBody: roles });
+  }
+  function generateNewApiKeyForUser(userId) {
+    return adminApi.gnerateNewApiKeyForUser({ userId });
+  }
+  function listRoles(filter, rowsPerPage, page) {
+    return adminApi.listRoles({ filter, rowsPerPage, page });
+  }
+  function getRole(roleName) {
+    return adminApi.getRole({ roleName });
+  }
+  function addRole(role) {
+    return adminApi.addRole({ role });
+  }
+  function updateRole(roleName, updateRoleRequest) {
+    return adminApi.updateRole({ roleName, updateRoleRequest });
+  }
+  function deleteRole(roleName) {
+    return adminApi.deleteRole({ roleName });
+  }
+  return { listUsers, getUser, addUser, deleteUser, updatePasswordForUser, updateRolesForUser, generateNewApiKeyForUser, listRoles, getRole, addRole, updateRole, deleteRole };
+}

package/dist/runtime/composables/mongocampApiCollection.d.ts

@@ -0,0 +1,26 @@
+import type { MongoAggregateRequest } from '../api/index.js';
+export declare function useMongocampApiCollection(collectionName: string): {
+    insert: (document: {
+        [key: string]: string;
+    }) => Promise<import("../api/index.js").InsertResponse>;
+    insertMany: (documents: Array<{
+        [key: string]: string;
+    }>) => Promise<import("../api/index.js").InsertResponse>;
+    update: (documentId: string, document: {
+        [key: string]: string;
+    }) => Promise<import("../api/index.js").UpdateResponse>;
+    updatePartial: (documentId: string, document: {
+        [key: string]: string;
+    }) => Promise<import("../api/index.js").UpdateResponse>;
+    remove: (documentId: string) => Promise<import("../api/index.js").DeleteResponse>;
+    removeMany: (query: {
+        [key: string]: string;
+    }) => Promise<import("../api/index.js").DeleteResponse>;
+    aggregate: (mongoAggregateRequest: MongoAggregateRequest, rowsPerPage?: number, page?: number) => Promise<{
+        [key: string]: string;
+    }[]>;
+    information: (includeDetails?: boolean) => Promise<import("../api/index.js").CollectionStatus>;
+    schemaAnalysis: () => Promise<import("../api/index.js").SchemaAnalysis>;
+    distinct: (field: string) => Promise<string[]>;
+    clear: () => Promise<import("../api/index.js").JsonValueBoolean>;
+};

package/dist/runtime/composables/mongocampApiCollection.js

@@ -0,0 +1,40 @@
+import { useMongocampApi } from "./mongocampApi.js";
+import { useRuntimeConfig } from "#app";
+export function useMongocampApiCollection(collectionName) {
+  const { documentApi, collectionApi } = useMongocampApi();
+  const config = useRuntimeConfig();
+  function insert(document) {
+    return documentApi.insert({ collectionName, requestBody: document });
+  }
+  function insertMany(documents) {
+    return documentApi.insertMany({ collectionName, requestBody: documents });
+  }
+  function update(documentId, document) {
+    return documentApi.update({ collectionName, documentId, requestBody: document });
+  }
+  function updatePartial(documentId, document) {
+    return documentApi.updateDocumentPartial({ collectionName, documentId, requestBody: document });
+  }
+  function remove(documentId) {
+    return documentApi._delete({ collectionName, documentId });
+  }
+  function removeMany(query) {
+    return documentApi.deleteMany({ collectionName, requestBody: query });
+  }
+  function aggregate(mongoAggregateRequest, rowsPerPage = config.public.mongocamp?.paginationSize, page = 1) {
+    return collectionApi.aggregate({ collectionName, mongoAggregateRequest, rowsPerPage, page });
+  }
+  function information(includeDetails = false) {
+    return collectionApi.getCollectionInformation({ collectionName, includeDetails });
+  }
+  function schemaAnalysis() {
+    return collectionApi.getSchemaAnalysis({ collectionName });
+  }
+  function distinct(field) {
+    return collectionApi.distinct({ collectionName, field });
+  }
+  function clear() {
+    return collectionApi.clearCollection({ collectionName });
+  }
+  return { insert, insertMany, update, updatePartial, remove, removeMany, aggregate, information, schemaAnalysis, distinct, clear };
+}

package/dist/runtime/composables/mongocampApiCollections.d.ts

@@ -0,0 +1,8 @@
+export declare function useMongocampApiCollections(): {
+    list: () => Promise<string[]>;
+    listByDatabase: (databaseName: string) => Promise<string[]>;
+    listDatabases: () => Promise<string[]>;
+    databaseInfo: (databaseName: string) => Promise<import("../api/index.js").DatabaseInfo>;
+    databaseInfos: () => Promise<import("../api/index.js").DatabaseInfo[]>;
+    deleteDatabase: (databaseName: string) => Promise<import("../api/index.js").JsonValueBoolean>;
+};

package/dist/runtime/composables/mongocampApiCollections.js

@@ -0,0 +1,23 @@
+import { useMongocampApi } from "./mongocampApi.js";
+export function useMongocampApiCollections() {
+  const { collectionApi, databaseApi } = useMongocampApi();
+  function list() {
+    return collectionApi.listCollections();
+  }
+  function listByDatabase(databaseName) {
+    return collectionApi.listCollectionsByDatabase({ databaseName });
+  }
+  function listDatabases() {
+    return databaseApi.listDatabases();
+  }
+  function databaseInfo(databaseName) {
+    return databaseApi.getDatabaseInfo({ databaseName });
+  }
+  function databaseInfos() {
+    return databaseApi.databaseInfos();
+  }
+  function deleteDatabase(databaseName) {
+    return databaseApi.deleteDatabase({ databaseName });
+  }
+  return { list, listByDatabase, listDatabases, databaseInfo, databaseInfos, deleteDatabase };
+}

package/dist/runtime/composables/mongocampApiFiles.d.ts

@@ -0,0 +1,14 @@
+import type { MongoFindRequest, UpdateFileInformationRequest } from '../api/index.js';
+export declare function useMongocampApiFiles(): {
+    listBuckets: () => Promise<string[]>;
+    getBucket: (bucketName: string) => Promise<import("../api/index.js").BucketInformation>;
+    clearBucket: (bucketName: string) => Promise<import("../api/index.js").JsonValueBoolean>;
+    deleteBucket: (bucketName: string) => Promise<import("../api/index.js").JsonValueBoolean>;
+    list: (bucketName: string, filter?: string, sort?: string, projection?: string, rowsPerPage?: number, page?: number) => Promise<import("../api/index.js").FileInformation[]>;
+    find: (bucketName: string, mongoFindRequest: MongoFindRequest, rowsPerPage?: number, page?: number) => Promise<import("../api/index.js").FileInformation[]>;
+    info: (bucketName: string, fileId: string) => Promise<import("../api/index.js").FileInformation>;
+    download: (bucketName: string, fileId: string) => Promise<Blob>;
+    upload: (bucketName: string, file: Blob, metaData: string, fileName?: string) => Promise<import("../api/index.js").InsertResponse>;
+    update: (bucketName: string, fileId: string, updateFileInformationRequest: UpdateFileInformationRequest) => Promise<import("../api/index.js").UpdateResponse>;
+    remove: (bucketName: string, fileId: string) => Promise<import("../api/index.js").DeleteResponse>;
+};

package/dist/runtime/composables/mongocampApiFiles.js

@@ -0,0 +1,38 @@
+import { useMongocampApi } from "./mongocampApi.js";
+export function useMongocampApiFiles() {
+  const { fileApi, bucketApi } = useMongocampApi();
+  function listBuckets() {
+    return bucketApi.listBuckets();
+  }
+  function getBucket(bucketName) {
+    return bucketApi.getBucket({ bucketName });
+  }
+  function clearBucket(bucketName) {
+    return bucketApi.clearBucket({ bucketName });
+  }
+  function deleteBucket(bucketName) {
+    return bucketApi.deleteBucket({ bucketName });
+  }
+  function list(bucketName, filter, sort, projection, rowsPerPage, page) {
+    return fileApi.listFiles({ bucketName, filter, sort, projection, rowsPerPage, page });
+  }
+  function find(bucketName, mongoFindRequest, rowsPerPage, page) {
+    return fileApi.findFiles({ bucketName, mongoFindRequest, rowsPerPage, page });
+  }
+  function info(bucketName, fileId) {
+    return fileApi.getFileInformation({ bucketName, fileId });
+  }
+  function download(bucketName, fileId) {
+    return fileApi.getFile({ bucketName, fileId });
+  }
+  function upload(bucketName, file, metaData, fileName) {
+    return fileApi.insertFile({ bucketName, file, metaData, fileName });
+  }
+  function update(bucketName, fileId, updateFileInformationRequest) {
+    return fileApi.updateFileInformation({ bucketName, fileId, updateFileInformationRequest });
+  }
+  function remove(bucketName, fileId) {
+    return fileApi.deleteFile({ bucketName, fileId });
+  }
+  return { listBuckets, getBucket, clearBucket, deleteBucket, list, find, info, download, upload, update, remove };
+}

package/dist/runtime/composables/mongocampApiJobs.d.ts

@@ -0,0 +1,9 @@
+import type { JobConfig } from '../api/index.js';
+export declare function useMongocampApiJobs(): {
+    list: () => Promise<import("../api/index.js").JobInformation[]>;
+    listAvailable: () => Promise<string[]>;
+    register: (jobConfig: JobConfig) => Promise<import("../api/index.js").JobInformation>;
+    update: (jobGroup: string, jobName: string, jobConfig: JobConfig) => Promise<import("../api/index.js").JobInformation>;
+    remove: (jobGroup: string, jobName: string) => Promise<import("../api/index.js").JsonValueBoolean>;
+    execute: (jobGroup: string, jobName: string) => Promise<import("../api/index.js").JsonValueBoolean>;
+};

package/dist/runtime/composables/mongocampApiJobs.js

@@ -0,0 +1,23 @@
+import { useMongocampApi } from "./mongocampApi.js";
+export function useMongocampApiJobs() {
+  const { jobApi } = useMongocampApi();
+  function list() {
+    return jobApi.jobsList();
+  }
+  function listAvailable() {
+    return jobApi.possibleJobsList();
+  }
+  function register(jobConfig) {
+    return jobApi.registerJob({ jobConfig });
+  }
+  function update(jobGroup, jobName, jobConfig) {
+    return jobApi.updateJob({ jobGroup, jobName, jobConfig });
+  }
+  function remove(jobGroup, jobName) {
+    return jobApi.deleteJob({ jobGroup, jobName });
+  }
+  function execute(jobGroup, jobName) {
+    return jobApi.executeJob({ jobGroup, jobName });
+  }
+  return { list, listAvailable, register, update, remove, execute };
+}

package/dist/runtime/composables/mongocampAuth.js

@@ -1,17 +1,28 @@
-import { computed } from "vue";
+import { computed, watch } from "vue";
 import { consola } from "consola";
+import { toMongocampError } from "../utils/toMongocampError.js";
 import { useMongocampApi } from "./mongocampApi.js";
 import { useMongocampStorage } from "./mongocampStorage.js";
 import { useMongocampUser } from "./mongocampUser.js";
-import { useRuntimeConfig } from "#app";
+import { useRuntimeConfig, useState } from "#app";
 export function useMongocampAuth() {
   const config = useRuntimeConfig();
   const refreshToken = config.public.mongocamp?.refreshToken;
-  const tokenRefreshIntervall = config.public.mongocamp?.tokenRefreshIntervall;
+  const tokenRefreshInterval = config.public.mongocamp?.tokenRefreshInterval;
   const state = useMongocampStorage();
   const { authApi } = useMongocampApi();
   const user = useMongocampUser();
-  let updateTokenInterval;
+  const updateTokenInterval = useState("mongocamp.tokenRefreshInterval", () => void 0);
+  function startTokenRefresh() {
+    if (import.meta.client && refreshToken && !updateTokenInterval.value)
+      updateTokenInterval.value = window.setInterval(updateToken, tokenRefreshInterval);
+  }
+  function stopTokenRefresh() {
+    if (import.meta.client && updateTokenInterval.value) {
+      window.clearInterval(updateTokenInterval.value);
+      updateTokenInterval.value = void 0;
+    }
+  }
   async function isAuthenticated() {
     return await authApi.isAuthenticated();
   }
@@ -20,7 +31,10 @@ export function useMongocampAuth() {
       const result = await authApi.refreshToken();
       updateUserState(result);
     } catch (e) {
-      consola.log(e);
+      const error = await toMongocampError(e);
+      consola.error(error.message, error.cause);
+      if (error.status === 401 || error.status === 403)
+        logout();
     }
   }
   function updateUserState(result) {
@@ -33,31 +47,25 @@ export function useMongocampAuth() {
     const login2 = { userId: loginId, password: loginPassword };
     const result = await authApi.login({ login: login2 });
     updateUserState(result);
-    if (refreshToken && import.meta.client) {
-      updateTokenInterval = window.setInterval(updateToken, tokenRefreshIntervall);
-    }
     return result.userProfile;
   };
   const logout = () => {
+    if (state.value.token)
+      authApi.logout().catch((e) => consola.error(e));
     state.value.token = "";
     const profile = { user: "", isAdmin: false };
     state.value.profile = profile;
     user.value = profile;
-    if (refreshToken && import.meta.client) {
-      window.clearInterval(updateTokenInterval);
-    }
   };
-  const isLoggedIn = computed(() => {
-    const result = state.value?.token?.length > 0;
-    if (import.meta.client) {
-      if (result && refreshToken && !updateTokenInterval) {
-        updateTokenInterval = window.setInterval(updateToken, tokenRefreshIntervall);
-      } else if (!result && updateTokenInterval) {
-        window.clearInterval(updateTokenInterval);
-      }
-    }
-    return result;
-  });
+  const isLoggedIn = computed(() => (state.value.token?.length ?? 0) > 0);
+  if (import.meta.client) {
+    watch(isLoggedIn, (loggedIn) => {
+      if (loggedIn)
+        startTokenRefresh();
+      else
+        stopTokenRefresh();
+    }, { immediate: true });
+  }
   const userRoles = computed(() => state.value.profile.roles ?? []);
   const userGrants = computed(() => state.value.profile.grants ?? []);
   return { login, logout, isAuthenticated, isLoggedIn, userRoles, userGrants };

package/dist/runtime/composables/mongocampSearch.d.ts

@@ -1,4 +1,5 @@
 import type { FindRequest, MongoFindRequest } from '../api/index.js';
+import type { FilterFieldValue } from '../utils/buildFieldFilterExpression.js';
 export declare function useMongocampSearch(): {
     mongoFindRequest: (filter?: object, sort?: object, projection?: object) => MongoFindRequest;
     findRequest: (collection: string, searchParameter?: MongoFindRequest, rows?: number, actualPage?: number) => FindRequest;
@@ -8,7 +9,28 @@ export declare function useMongocampSearch(): {
     findAll: (collectionName: string, page?: number, sort?: string[] | undefined, projection?: string[] | undefined, rowsPerPage?: number) => Promise<{
         [key: string]: string;
     }[]>;
-    findByField: (collectionName: string, field: string, value: string, page?: number, sort?: string[] | undefined, projection?: string[] | undefined, rowsPerPage?: number) => Promise<{
+    findByField: (collectionName: string, field: string, value: FilterFieldValue, page?: number, sort?: string[] | undefined, projection?: string[] | undefined, rowsPerPage?: number) => Promise<{
         [key: string]: string;
     }[]>;
 };
+export interface PaginatedFindOptions {
+    filter?: string;
+    sort?: string[];
+    projection?: string[];
+    rowsPerPage?: number;
+}
+export declare function usePaginatedFind(collectionName: string, options?: PaginatedFindOptions): {
+    documents: import("vue").Ref<{
+        [key: string]: string;
+    }[], {
+        [key: string]: string;
+    }[]>;
+    page: import("vue").Ref<number, number>;
+    rowsPerPage: any;
+    pending: import("vue").Ref<boolean, boolean>;
+    error: import("vue").Ref<unknown, unknown>;
+    load: () => Promise<void>;
+    nextPage: () => Promise<void>;
+    previousPage: () => Promise<void>;
+    goToPage: (target: number) => Promise<void>;
+};

package/dist/runtime/composables/mongocampSearch.js

@@ -1,3 +1,5 @@
+import { ref } from "vue";
+import { buildFieldFilterExpression } from "../utils/buildFieldFilterExpression.js";
 import { useMongocampApi } from "./mongocampApi.js";
 import { useRuntimeConfig } from "#app";
 export function useMongocampSearch() {
@@ -16,8 +18,39 @@ export function useMongocampSearch() {
     return find(collectionName, void 0, page, sort, projection, rowsPerPage);
   }
   function findByField(collectionName, field, value, page = 1, sort = void 0, projection = void 0, rowsPerPage = config.public.mongocamp?.paginationSize) {
-    const expression = `${field}: ${value}`;
+    const expression = buildFieldFilterExpression(field, value);
     return find(collectionName, expression, page, sort, projection, rowsPerPage);
   }
   return { mongoFindRequest, findRequest, find, findAll, findByField };
 }
+export function usePaginatedFind(collectionName, options = {}) {
+  const { find } = useMongocampSearch();
+  const config = useRuntimeConfig();
+  const page = ref(1);
+  const rowsPerPage = ref(options.rowsPerPage ?? config.public.mongocamp?.paginationSize);
+  const documents = ref([]);
+  const pending = ref(false);
+  const error = ref(null);
+  async function load() {
+    pending.value = true;
+    error.value = null;
+    try {
+      documents.value = await find(collectionName, options.filter, page.value, options.sort, options.projection, rowsPerPage.value);
+    } catch (e) {
+      error.value = e;
+    } finally {
+      pending.value = false;
+    }
+  }
+  function goToPage(target) {
+    page.value = Math.max(1, target);
+    return load();
+  }
+  function nextPage() {
+    return goToPage(page.value + 1);
+  }
+  function previousPage() {
+    return goToPage(page.value - 1);
+  }
+  return { documents, page, rowsPerPage, pending, error, load, nextPage, previousPage, goToPage };
+}

package/dist/runtime/composables/mongocampStorage.d.ts

@@ -1,5 +1,6 @@
 import type { UserProfile } from '../api/index.js';
-export declare function useMongocampStorage(): import("@vueuse/shared").RemovableRef<{
+export interface MongocampSession {
     token: string;
     profile: UserProfile;
-}>;
+}
+export declare function useMongocampStorage(): import("nuxt/app").CookieRef<MongocampSession>;

package/dist/runtime/composables/mongocampStorage.js

@@ -1,5 +1,6 @@
-import { useSessionStorage } from "@vueuse/core";
+import { useCookie } from "#app";
 export function useMongocampStorage() {
-  const profile = { user: "", isAdmin: false };
-  return useSessionStorage("mongocamp", { token: "", profile });
+  return useCookie("mongocamp", {
+    default: () => ({ token: "", profile: { user: "", isAdmin: false } })
+  });
 }

package/dist/runtime/composables/mongocampUser.js

@@ -1,4 +1,4 @@
 import { useState } from "#app";
 export function useMongocampUser() {
-  return useState("mongocamp.user");
+  return useState("mongocamp.user", () => ({ user: "", isAdmin: false }));
 }

package/dist/runtime/server/composables/mongocampApi.d.ts

@@ -0,0 +1,14 @@
+import type { H3Event } from 'h3';
+export declare function useMongocampApi(event: H3Event, token?: string): {
+    adminApi: import("../../api/index.js").AdminApi;
+    applicationApi: import("../../api/index.js").ApplicationApi;
+    authApi: import("../../api/index.js").AuthApi;
+    bucketApi: import("../../api/index.js").BucketApi;
+    collectionApi: import("../../api/index.js").CollectionApi;
+    databaseApi: import("../../api/index.js").DatabaseApi;
+    documentApi: import("../../api/index.js").DocumentApi;
+    fileApi: import("../../api/index.js").FileApi;
+    indexApi: import("../../api/index.js").IndexApi;
+    informationApi: import("../../api/index.js").InformationApi;
+    jobApi: import("../../api/index.js").JobsApi;
+};

package/dist/runtime/server/composables/mongocampApi.js

@@ -0,0 +1,8 @@
+import { useRuntimeConfig } from "#imports";
+import { useMongocampServerApi } from "./mongocampServerApi.js";
+export function useMongocampApi(event, token) {
+  const config = useRuntimeConfig(event);
+  const url = config.public.mongocamp?.url;
+  const apiKey = config.mongocampApiKey;
+  return useMongocampServerApi(url, apiKey, token);
+}

package/dist/runtime/server/composables/mongocampServerApi.d.ts

@@ -1,14 +1,13 @@
-import { AdminApi, ApplicationApi, AuthApi, BucketApi, CollectionApi, DatabaseApi, DocumentApi, FileApi, IndexApi, InformationApi, JobsApi } from '../../api/index.js';
 export declare function useMongocampServerApi(url: string, key?: string, token?: string): {
-    adminApi: AdminApi;
-    applicationApi: ApplicationApi;
-    authApi: AuthApi;
-    bucketApi: BucketApi;
-    collectionApi: CollectionApi;
-    databaseApi: DatabaseApi;
-    documentApi: DocumentApi;
-    fileApi: FileApi;
-    indexApi: IndexApi;
-    informationApi: InformationApi;
-    jobApi: JobsApi;
+    adminApi: import("../../api/index.js").AdminApi;
+    applicationApi: import("../../api/index.js").ApplicationApi;
+    authApi: import("../../api/index.js").AuthApi;
+    bucketApi: import("../../api/index.js").BucketApi;
+    collectionApi: import("../../api/index.js").CollectionApi;
+    databaseApi: import("../../api/index.js").DatabaseApi;
+    documentApi: import("../../api/index.js").DocumentApi;
+    fileApi: import("../../api/index.js").FileApi;
+    indexApi: import("../../api/index.js").IndexApi;
+    informationApi: import("../../api/index.js").InformationApi;
+    jobApi: import("../../api/index.js").JobsApi;
 };

package/dist/runtime/server/composables/mongocampServerApi.js

@@ -1,45 +1,10 @@
-import {
-  AdminApi,
-  ApplicationApi,
-  AuthApi,
-  BucketApi,
-  CollectionApi,
-  Configuration,
-  DatabaseApi,
-  DocumentApi,
-  FileApi,
-  IndexApi,
-  InformationApi,
-  JobsApi
-} from "../../api/index.js";
+import { Configuration } from "../../api/index.js";
+import { createMongocampApis } from "../../utils/createMongocampApis.js";
 export function useMongocampServerApi(url, key, token) {
-  let configuration = new Configuration();
+  let configuration = new Configuration({ basePath: url });
   if (key && key.length > 0)
     configuration = new Configuration({ basePath: url, apiKey: key });
   else if (token && token.length > 0)
     configuration = new Configuration({ basePath: url, accessToken: token });
-  const adminApi = new AdminApi(configuration);
-  const applicationApi = new ApplicationApi(configuration);
-  const authApi = new AuthApi(configuration);
-  const bucketApi = new BucketApi(configuration);
-  const collectionApi = new CollectionApi(configuration);
-  const databaseApi = new DatabaseApi(configuration);
-  const documentApi = new DocumentApi(configuration);
-  const fileApi = new FileApi(configuration);
-  const indexApi = new IndexApi(configuration);
-  const informationApi = new InformationApi(configuration);
-  const jobApi = new JobsApi(configuration);
-  return {
-    adminApi,
-    applicationApi,
-    authApi,
-    bucketApi,
-    collectionApi,
-    databaseApi,
-    documentApi,
-    fileApi,
-    indexApi,
-    informationApi,
-    jobApi
-  };
+  return createMongocampApis(configuration);
 }

package/dist/runtime/utils/buildFieldFilterExpression.d.ts

@@ -0,0 +1,2 @@
+export type FilterFieldValue = string | number | boolean | Date;
+export declare function buildFieldFilterExpression(field: string, value: FilterFieldValue): string;

package/dist/runtime/utils/buildFieldFilterExpression.js

@@ -0,0 +1,7 @@
+export function buildFieldFilterExpression(field, value) {
+  if (typeof value === "number" || typeof value === "boolean")
+    return `${field}: ${value}`;
+  const stringValue = value instanceof Date ? value.toISOString() : value;
+  const escapedValue = stringValue.replace(/"/g, '\\"');
+  return `${field}: "${escapedValue}"`;
+}

package/dist/runtime/utils/createMongocampApis.d.ts

@@ -0,0 +1,15 @@
+import type { Configuration } from '../api/index.js';
+import { AdminApi, ApplicationApi, AuthApi, BucketApi, CollectionApi, DatabaseApi, DocumentApi, FileApi, IndexApi, InformationApi, JobsApi } from '../api/index.js';
+export declare function createMongocampApis(configuration: Configuration): {
+    adminApi: AdminApi;
+    applicationApi: ApplicationApi;
+    authApi: AuthApi;
+    bucketApi: BucketApi;
+    collectionApi: CollectionApi;
+    databaseApi: DatabaseApi;
+    documentApi: DocumentApi;
+    fileApi: FileApi;
+    indexApi: IndexApi;
+    informationApi: InformationApi;
+    jobApi: JobsApi;
+};