@sfxcode/nuxt-ui-mongocamp 1.1.0

package/dist/runtime/components/MongocampUsers.vue

@@ -0,0 +1,320 @@
+<script setup>
+import { h, reactive, ref, resolveComponent } from "vue";
+import useMongocampAdmin from "../composables/useMongocampAdmin";
+const { listUsers, addUser, deleteUser, updateUserRoles, updateUserPassword, listRoles } = useMongocampAdmin();
+const users = ref([]);
+const loading = ref(false);
+const filterText = ref("");
+const sorting = ref([]);
+let filterTimer;
+const isAddModalOpen = ref(false);
+const isEditModalOpen = ref(false);
+const isDeleteModalOpen = ref(false);
+const userToDelete = ref("");
+const errorMessage = ref("");
+const newUser = ref({
+  userId: "",
+  password: "",
+  roles: []
+});
+const editUser = ref({
+  userId: "",
+  password: "",
+  roles: []
+});
+const addUserSchema = reactive([
+  {
+    $formkit: "nuxtUIInput",
+    name: "userId",
+    label: "Email",
+    validation: "required|email"
+  },
+  {
+    $formkit: "nuxtUIInput",
+    name: "password",
+    label: "Password",
+    inputType: "password",
+    validation: "required|length:3"
+  },
+  {
+    $formkit: "nuxtUIListbox",
+    name: "roles",
+    label: "Roles",
+    displayMode: "transfer",
+    options: [],
+    filter: true,
+    class: "h-60",
+    transferHeaderClass: "text-sm text-gray-500 font-medium",
+    transferAll: true,
+    transferLeftHeaderText: "Available",
+    transferRightHeaderText: "Assigned"
+  }
+]);
+const editUserSchema = reactive([
+  {
+    $formkit: "nuxtUIInput",
+    name: "password",
+    label: "New Password",
+    inputType: "password",
+    validation: "length:3,100",
+    help: "Leave empty to keep current password"
+  },
+  {
+    $formkit: "nuxtUIListbox",
+    name: "roles",
+    label: "Roles",
+    displayMode: "transfer",
+    filter: true,
+    class: "h-60",
+    transferHeaderClass: "text-sm text-gray-500 font-medium",
+    options: [],
+    transferAll: true,
+    transferLeftHeaderText: "Available",
+    transferRightHeaderText: "Assigned"
+  }
+]);
+async function fetchUsers() {
+  loading.value = true;
+  try {
+    users.value = await listUsers(filterText.value);
+  } finally {
+    loading.value = false;
+  }
+}
+function onFilterInput() {
+  clearTimeout(filterTimer);
+  filterTimer = setTimeout(() => fetchUsers(), 300);
+}
+async function fetchRoles() {
+  const roles = await listRoles();
+  const items = roles.map((r) => ({ value: r.name, label: r.name }));
+  addUserSchema[2].options = items;
+  editUserSchema[1].options = items;
+}
+async function handleAddUser() {
+  errorMessage.value = "";
+  try {
+    const roles = newUser.value.roles.map((r) => r.value);
+    await addUser(newUser.value.userId, newUser.value.password, "", roles);
+    isAddModalOpen.value = false;
+    newUser.value = { userId: "", password: "", roles: [] };
+    await fetchUsers();
+  } catch (e) {
+    errorMessage.value = e instanceof Error ? e.message : "Failed to add user";
+  }
+}
+function openEdit(user) {
+  editUser.value = {
+    userId: user.user,
+    password: "",
+    roles: (user.roles ?? []).map((r) => ({ value: r, label: r }))
+  };
+  isEditModalOpen.value = true;
+}
+async function handleEditUser() {
+  errorMessage.value = "";
+  try {
+    const roles = editUser.value.roles.map((r) => r.value);
+    await updateUserRoles(editUser.value.userId, roles);
+    if (editUser.value.password) {
+      await updateUserPassword(editUser.value.userId, editUser.value.password);
+    }
+    isEditModalOpen.value = false;
+    await fetchUsers();
+  } catch (e) {
+    errorMessage.value = e instanceof Error ? e.message : "Failed to update user";
+  }
+}
+function confirmDelete(userId) {
+  userToDelete.value = userId;
+  isDeleteModalOpen.value = true;
+}
+async function handleDeleteUser() {
+  await deleteUser(userToDelete.value);
+  isDeleteModalOpen.value = false;
+  await fetchUsers();
+}
+const UBadge = resolveComponent("UBadge");
+const UButton = resolveComponent("UButton");
+const UTooltip = resolveComponent("UTooltip");
+function withTooltip(text, node) {
+  return h(UTooltip, { text }, { default: () => node });
+}
+function sortHeader(column, label) {
+  const isSorted = column.getIsSorted();
+  return h(UButton, {
+    color: "neutral",
+    variant: "ghost",
+    label,
+    icon: isSorted === "asc" ? "i-lucide-arrow-up-narrow-wide" : isSorted === "desc" ? "i-lucide-arrow-down-wide-narrow" : "i-lucide-arrow-up-down",
+    class: "-mx-2.5",
+    onClick: () => column.toggleSorting(isSorted === "asc")
+  });
+}
+const columns = [
+  {
+    accessorKey: "user",
+    header: ({ column }) => sortHeader(column, "User")
+  },
+  {
+    accessorKey: "isAdmin",
+    header: ({ column }) => sortHeader(column, "Admin"),
+    cell: ({ row }) => h(UBadge, {
+      label: row.original.isAdmin ? "Admin" : "User",
+      color: row.original.isAdmin ? "error" : "neutral",
+      variant: "subtle"
+    })
+  },
+  {
+    accessorKey: "roles",
+    header: "Roles",
+    cell: ({ row }) => {
+      const roles = row.original.roles ?? [];
+      if (!roles.length)
+        return h("span", { class: "text-dimmed" }, "\u2014");
+      return h(
+        "div",
+        { class: "flex flex-wrap gap-1" },
+        roles.map((role) => h(UBadge, { label: role, color: "primary", variant: "subtle" }))
+      );
+    }
+  },
+  {
+    id: "actions",
+    header: "",
+    cell: ({ row }) => h("div", { class: "flex gap-1 justify-end" }, [
+      withTooltip("Edit user", h(UButton, {
+        "icon": "i-lucide-pencil",
+        "color": "neutral",
+        "variant": "ghost",
+        "size": "sm",
+        "aria-label": "Edit user",
+        "onClick": () => openEdit(row.original)
+      })),
+      withTooltip("Delete user", h(UButton, {
+        "icon": "i-lucide-trash-2",
+        "color": "error",
+        "variant": "ghost",
+        "size": "sm",
+        "aria-label": "Delete user",
+        "onClick": () => confirmDelete(row.original.user)
+      }))
+    ])
+  }
+];
+fetchUsers();
+fetchRoles();
+</script>
+
+<template>
+  <div class="flex flex-col gap-4">
+    <div class="flex items-center justify-between gap-4">
+      <h2 class="text-xl font-semibold">
+        Users
+      </h2>
+      <div class="flex flex-1 items-center gap-2">
+        <UInput
+          v-model="filterText"
+          icon="i-lucide-search"
+          placeholder="Search users..."
+          size="sm"
+          class="flex-1 max-w-xs"
+          @input="onFilterInput"
+        />
+        <UTooltip text="Refresh">
+          <UButton
+            icon="i-lucide-refresh-cw"
+            color="neutral"
+            variant="ghost"
+            :loading="loading"
+            aria-label="Refresh"
+            @click="fetchUsers"
+          />
+        </UTooltip>
+        <UButton
+          icon="i-lucide-plus"
+          label="Add User"
+          @click="isAddModalOpen = true"
+        />
+      </div>
+    </div>
+
+    <UTable
+      v-model:sorting="sorting"
+      :data="users"
+      :columns="columns"
+      :loading="loading"
+    />
+
+    <!-- Add User Modal -->
+    <UModal
+      v-model:open="isAddModalOpen"
+      title="Add User"
+    >
+      <template #body>
+        <FUDataEdit
+          :data="newUser"
+          :schema="addUserSchema"
+          submit-label="Add User"
+          submit-icon="i-lucide-plus"
+          @data-saved="handleAddUser"
+        />
+        <p
+          v-if="errorMessage"
+          class="mt-2 text-sm text-error-500"
+        >
+          {{ errorMessage }}
+        </p>
+      </template>
+    </UModal>
+
+    <!-- Edit User Modal -->
+    <UModal
+      v-model:open="isEditModalOpen"
+      :title="`Edit User: ${editUser.userId}`"
+    >
+      <template #body>
+        <FUDataEdit
+          :data="editUser"
+          :schema="editUserSchema"
+          submit-label="Save Changes"
+          submit-icon="i-lucide-save"
+          @data-saved="handleEditUser"
+        />
+        <p
+          v-if="errorMessage"
+          class="mt-2 text-sm text-error-500"
+        >
+          {{ errorMessage }}
+        </p>
+      </template>
+    </UModal>
+
+    <!-- Delete Confirmation Modal -->
+    <UModal
+      v-model:open="isDeleteModalOpen"
+      title="Delete User"
+      :ui="{ footer: 'justify-end' }"
+    >
+      <template #body>
+        <p>
+          Are you sure you want to delete user <strong>{{ userToDelete }}</strong>?
+          This action cannot be undone.
+        </p>
+      </template>
+      <template #footer>
+        <UButton
+          label="Cancel"
+          color="neutral"
+          variant="ghost"
+          @click="isDeleteModalOpen = false"
+        />
+        <UButton
+          label="Delete"
+          color="error"
+          @click="handleDeleteUser"
+        />
+      </template>
+    </UModal>
+  </div>
+</template>

package/dist/runtime/components/MongocampUsers.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/MongocampVersion.d.vue.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/MongocampVersion.vue

@@ -0,0 +1,25 @@
+<script setup>
+import { computed } from "vue";
+import { useNuxtApp } from "#app";
+const { $mongocampVersion } = useNuxtApp();
+const version = computed(() => $mongocampVersion.value);
+</script>
+
+<template>
+  <UBadge
+    v-if="version"
+    color="primary"
+    variant="subtle"
+    icon="i-lucide-database"
+  >
+    {{ version.name }} v{{ version.version }}
+  </UBadge>
+  <UBadge
+    v-else
+    color="neutral"
+    variant="subtle"
+    icon="i-lucide-database-zap"
+  >
+    MongoCamp unavailable
+  </UBadge>
+</template>

package/dist/runtime/components/MongocampVersion.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

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

@@ -0,0 +1,7 @@
+import type { UserProfile } from '@sfxcode/nuxt-mongocamp-server';
+export declare function useMongocampAccount(): {
+    changingPassword: import("vue").Ref<boolean, boolean>;
+    fetchProfile: () => Promise<UserProfile>;
+    changePassword: (password: string) => Promise<boolean>;
+    regenerateApiKey: () => Promise<string>;
+};

package/dist/runtime/composables/useMongocampAccount.js

@@ -0,0 +1,28 @@
+import { ref } from "vue";
+import { useMongocampApi, useToast } from "#imports";
+export function useMongocampAccount() {
+  const { authApi } = useMongocampApi();
+  const toast = useToast();
+  const changingPassword = ref(false);
+  async function fetchProfile() {
+    return authApi.userProfile();
+  }
+  async function changePassword(password) {
+    changingPassword.value = true;
+    try {
+      const result = await authApi.updatePassword({ passwordUpdateRequest: { password } });
+      toast.add({ title: "Password changed", description: "Your password was updated.", color: "success" });
+      return result.value;
+    } catch {
+      toast.add({ title: "Change failed", description: "Could not change your password.", color: "error" });
+      return false;
+    } finally {
+      changingPassword.value = false;
+    }
+  }
+  async function regenerateApiKey() {
+    const result = await authApi.generateNewApiKey();
+    return result.value;
+  }
+  return { changingPassword, fetchProfile, changePassword, regenerateApiKey };
+}

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

@@ -0,0 +1,14 @@
+import type { Grant, Role, UserProfile } from '@sfxcode/nuxt-mongocamp-server';
+declare const _default: () => {
+    listUsers: (filter?: string) => Promise<UserProfile[]>;
+    addUser: (userId: string, password: string, apiKey?: string, roles?: string[]) => Promise<UserProfile>;
+    deleteUser: (userId: string) => Promise<import("@sfxcode/nuxt-mongocamp-server").JsonValueBoolean>;
+    updateUserRoles: (userId: string, roles: string[]) => Promise<UserProfile>;
+    updateUserPassword: (userId: string, password: string) => Promise<import("@sfxcode/nuxt-mongocamp-server").JsonValueBoolean>;
+    listRoles: (filter?: string) => Promise<Role[]>;
+    addRole: (name: string, isAdmin?: boolean, collectionGrants?: Grant[]) => Promise<Role>;
+    updateRole: (roleName: string, isAdmin: boolean, collectionGrants?: Grant[]) => Promise<Role>;
+    deleteRole: (roleName: string) => Promise<import("@sfxcode/nuxt-mongocamp-server").JsonValueBoolean>;
+    listCollections: () => Promise<string[]>;
+};
+export default _default;

package/dist/runtime/composables/useMongocampAdmin.js

@@ -0,0 +1,48 @@
+import { useMongocampApi } from "#imports";
+export default () => {
+  const { adminApi, collectionApi } = useMongocampApi();
+  async function listUsers(filter = "") {
+    return adminApi.listUsers({ filter });
+  }
+  async function addUser(userId, password, apiKey = "", roles = []) {
+    return adminApi.addUser({
+      userInformation: {
+        userId,
+        password,
+        apiKey,
+        roles
+      }
+    });
+  }
+  async function deleteUser(userId) {
+    return adminApi.deleteUser({ userId });
+  }
+  async function updateUserRoles(userId, roles) {
+    return adminApi.updateRolesForUser({ userId, requestBody: roles });
+  }
+  async function updateUserPassword(userId, password) {
+    return adminApi.updatePasswordForUser({ userId, passwordUpdateRequest: { password } });
+  }
+  async function listRoles(filter = "") {
+    return adminApi.listRoles({ filter });
+  }
+  async function listCollections() {
+    return collectionApi.listCollections();
+  }
+  async function addRole(name, isAdmin = false, collectionGrants = []) {
+    return adminApi.addRole({
+      role: {
+        name,
+        isAdmin,
+        collectionGrants
+      }
+    });
+  }
+  async function updateRole(roleName, isAdmin, collectionGrants = []) {
+    return adminApi.updateRole({ roleName, updateRoleRequest: { isAdmin, collectionGrants } });
+  }
+  async function deleteRole(roleName) {
+    return adminApi.deleteRole({ roleName });
+  }
+  return { listUsers, addUser, deleteUser, updateUserRoles, updateUserPassword, listRoles, addRole, updateRole, deleteRole, listCollections };
+};

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

@@ -0,0 +1,15 @@
+import type { BucketInformation } from '@sfxcode/nuxt-mongocamp-server';
+export declare function useMongocampBucket(): {
+    isBucketCollection: (collectionName: string) => boolean;
+    bucketNameFor: (collectionName: string) => string;
+    fileIdForRow: (collectionName: string, row: Record<string, unknown>) => string | undefined;
+    downloadingFileIds: import("vue").Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    uploading: import("vue").Ref<boolean, boolean>;
+    downloadFile: (collectionName: string, fileId: string) => Promise<void>;
+    uploadFile: (collectionName: string, file: File) => Promise<boolean>;
+    bucketActionInFlight: import("vue").Ref<Set<string> & Omit<Set<string>, keyof Set<any>>, Set<string> | (Set<string> & Omit<Set<string>, keyof Set<any>>)>;
+    listBuckets: () => Promise<string[]>;
+    getBucketInfo: (bucketName: string) => Promise<BucketInformation>;
+    clearBucket: (bucketName: string) => Promise<boolean>;
+    deleteBucket: (bucketName: string) => Promise<boolean>;
+};

package/dist/runtime/composables/useMongocampBucket.js

@@ -0,0 +1,109 @@
+import { ref } from "vue";
+import { useMongocampApi, useToast } from "#imports";
+const BUCKET_COLLECTION_SUFFIX = /\.(?:files|chunks)$/;
+function unwrapId(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && value !== null && "$oid" in value) {
+    return String(value.$oid);
+  }
+  return void 0;
+}
+function triggerBrowserDownload(blob, filename) {
+  const url = URL.createObjectURL(blob);
+  const link = document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  document.body.appendChild(link);
+  link.click();
+  document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+export function useMongocampBucket() {
+  const { fileApi, bucketApi } = useMongocampApi();
+  const toast = useToast();
+  const downloadingFileIds = ref(/* @__PURE__ */ new Set());
+  const uploading = ref(false);
+  const bucketActionInFlight = ref(/* @__PURE__ */ new Set());
+  function isBucketCollection(collectionName) {
+    return BUCKET_COLLECTION_SUFFIX.test(collectionName);
+  }
+  function bucketNameFor(collectionName) {
+    return collectionName.replace(BUCKET_COLLECTION_SUFFIX, "");
+  }
+  function fileIdForRow(collectionName, row) {
+    return collectionName.endsWith(".chunks") ? unwrapId(row.files_id) : unwrapId(row._id);
+  }
+  async function downloadFile(collectionName, fileId) {
+    const bucketName = bucketNameFor(collectionName);
+    downloadingFileIds.value.add(fileId);
+    try {
+      const info = await fileApi.getFileInformation({ bucketName, fileId });
+      const blob = await fileApi.getFile({ bucketName, fileId });
+      triggerBrowserDownload(blob, info.filename || fileId);
+    } catch {
+      toast.add({ title: "Download failed", description: "Could not download the file.", color: "error" });
+    } finally {
+      downloadingFileIds.value.delete(fileId);
+    }
+  }
+  async function uploadFile(collectionName, file) {
+    const bucketName = bucketNameFor(collectionName);
+    uploading.value = true;
+    try {
+      await fileApi.insertFile({ bucketName, file, fileName: file.name, metaData: "{}" });
+      toast.add({ title: "File uploaded", description: `"${file.name}" was uploaded.`, color: "success" });
+      return true;
+    } catch {
+      toast.add({ title: "Upload failed", description: "Could not upload the file.", color: "error" });
+      return false;
+    } finally {
+      uploading.value = false;
+    }
+  }
+  async function listBuckets() {
+    return bucketApi.listBuckets();
+  }
+  async function getBucketInfo(bucketName) {
+    return bucketApi.getBucket({ bucketName });
+  }
+  async function clearBucket(bucketName) {
+    bucketActionInFlight.value.add(bucketName);
+    try {
+      const result = await bucketApi.clearBucket({ bucketName });
+      toast.add({ title: "Bucket cleared", description: `All files in "${bucketName}" were deleted.`, color: "success" });
+      return result.value;
+    } catch {
+      toast.add({ title: "Clear failed", description: `Could not clear bucket "${bucketName}".`, color: "error" });
+      return false;
+    } finally {
+      bucketActionInFlight.value.delete(bucketName);
+    }
+  }
+  async function deleteBucket(bucketName) {
+    bucketActionInFlight.value.add(bucketName);
+    try {
+      const result = await bucketApi.deleteBucket({ bucketName });
+      toast.add({ title: "Bucket deleted", description: `Bucket "${bucketName}" was deleted.`, color: "success" });
+      return result.value;
+    } catch {
+      toast.add({ title: "Delete failed", description: `Could not delete bucket "${bucketName}".`, color: "error" });
+      return false;
+    } finally {
+      bucketActionInFlight.value.delete(bucketName);
+    }
+  }
+  return {
+    isBucketCollection,
+    bucketNameFor,
+    fileIdForRow,
+    downloadingFileIds,
+    uploading,
+    downloadFile,
+    uploadFile,
+    bucketActionInFlight,
+    listBuckets,
+    getBucketInfo,
+    clearBucket,
+    deleteBucket
+  };
+}

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

@@ -0,0 +1,17 @@
+declare const _default: () => {
+    filter: import("vue").Ref<string | undefined, string | undefined>;
+    sort: import("vue").Ref<string[] | undefined, string[] | undefined>;
+    projection: import("vue").Ref<string[] | undefined, string[] | undefined>;
+    pagination: import("vue").Ref<{
+        pageIndex: number;
+        pageSize: number;
+    }, {
+        pageIndex: number;
+        pageSize: number;
+    } | {
+        pageIndex: number;
+        pageSize: number;
+    }>;
+    total: import("vue").Ref<number, number>;
+};
+export default _default;

package/dist/runtime/composables/useMongocampCollection.js

@@ -0,0 +1,12 @@
+import { ref } from "vue";
+export default () => {
+  const filter = ref();
+  const sort = ref();
+  const projection = ref();
+  const pagination = ref({
+    pageIndex: 1,
+    pageSize: 20
+  });
+  const total = ref(0);
+  return { filter, sort, projection, pagination, total };
+};

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

@@ -0,0 +1,13 @@
+interface MetaData {
+    createdBy: string;
+    updatedBy: string;
+    created: string | Date;
+    updated: string | Date;
+}
+declare const _default: () => {
+    ensureMetaData: <T extends {
+        metaData?: Partial<MetaData>;
+    }>(data: T) => T;
+    updateFromPartial: <T>(obj: T, updates: Partial<T>) => T;
+};
+export default _default;

package/dist/runtime/composables/useMongocampDocument.js

@@ -0,0 +1,18 @@
+import { useMongocampStorage } from "#imports";
+export default () => {
+  function ensureMetaData(data) {
+    const storage = useMongocampStorage();
+    const userId = storage.value?.profile.user ?? "";
+    const now = /* @__PURE__ */ new Date();
+    if (!data.metaData || !data.metaData.createdBy) {
+      data.metaData = { createdBy: userId, updatedBy: userId, created: now, updated: now };
+    } else {
+      data.metaData = { createdBy: data.metaData.createdBy, updatedBy: userId, created: data.metaData.created ?? now, updated: now };
+    }
+    return data;
+  }
+  function updateFromPartial(obj, updates) {
+    return { ...obj, ...updates };
+  }
+  return { ensureMetaData, updateFromPartial };
+};

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

@@ -0,0 +1,14 @@
+import type { ColumnDefinition } from './useMongocampSchema.js';
+export interface FormKitSchemaNode {
+    $formkit?: string;
+    $el?: string;
+    name?: string;
+    label?: string;
+    validation?: string;
+    attrs?: Record<string, unknown>;
+    children?: FormKitSchemaNode[];
+    [key: string]: unknown;
+}
+export declare function columnsToFormKitSchema(columns: ColumnDefinition[]): FormKitSchemaNode[];
+export declare function documentToFormData(doc: Record<string, unknown>, columns: ColumnDefinition[]): Record<string, unknown>;
+export declare function formDataToDocument(formData: Record<string, unknown>, columns: ColumnDefinition[], originalDoc?: Record<string, unknown>): Record<string, unknown>;