@sfxcode/nuxt-mongocamp-server 1.0.4 → 1.0.6

package/dist/runtime/api/runtime.mjs

@@ -0,0 +1,289 @@
+export const BASE_PATH = "http://localhost".replace(/\/+$/, "");
+export class Configuration {
+  constructor(configuration = {}) {
+    this.configuration = configuration;
+  }
+  set config(configuration) {
+    this.configuration = configuration;
+  }
+  get basePath() {
+    return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+  }
+  get fetchApi() {
+    return this.configuration.fetchApi;
+  }
+  get middleware() {
+    return this.configuration.middleware || [];
+  }
+  get queryParamsStringify() {
+    return this.configuration.queryParamsStringify || querystring;
+  }
+  get username() {
+    return this.configuration.username;
+  }
+  get password() {
+    return this.configuration.password;
+  }
+  get apiKey() {
+    const apiKey = this.configuration.apiKey;
+    if (apiKey) {
+      return typeof apiKey === "function" ? apiKey : () => apiKey;
+    }
+    return void 0;
+  }
+  get accessToken() {
+    const accessToken = this.configuration.accessToken;
+    if (accessToken) {
+      return typeof accessToken === "function" ? accessToken : async () => accessToken;
+    }
+    return void 0;
+  }
+  get headers() {
+    return this.configuration.headers;
+  }
+  get credentials() {
+    return this.configuration.credentials;
+  }
+}
+export const DefaultConfig = new Configuration();
+export class BaseAPI {
+  constructor(configuration = DefaultConfig) {
+    this.configuration = configuration;
+    this.middleware = configuration.middleware;
+  }
+  static jsonRegex = new RegExp("^(:?application/json|[^;/ 	]+/[^;/ 	]+[+]json)[ 	]*(:?;.*)?$", "i");
+  middleware;
+  withMiddleware(...middlewares) {
+    const next = this.clone();
+    next.middleware = next.middleware.concat(...middlewares);
+    return next;
+  }
+  withPreMiddleware(...preMiddlewares) {
+    const middlewares = preMiddlewares.map((pre) => ({ pre }));
+    return this.withMiddleware(...middlewares);
+  }
+  withPostMiddleware(...postMiddlewares) {
+    const middlewares = postMiddlewares.map((post) => ({ post }));
+    return this.withMiddleware(...middlewares);
+  }
+  /**
+   * Check if the given MIME is a JSON MIME.
+   * JSON MIME examples:
+   *   application/json
+   *   application/json; charset=UTF8
+   *   APPLICATION/JSON
+   *   application/vnd.company+json
+   * @param mime - MIME (Multipurpose Internet Mail Extensions)
+   * @return True if the given MIME is JSON, false otherwise.
+   */
+  isJsonMime(mime) {
+    if (!mime) {
+      return false;
+    }
+    return BaseAPI.jsonRegex.test(mime);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = await this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response && (response.status >= 200 && response.status < 300)) {
+      return response;
+    }
+    throw new ResponseError(response, "Response returned an error code");
+  }
+  async createFetchParams(context, initOverrides) {
+    let url = this.configuration.basePath + context.path;
+    if (context.query !== void 0 && Object.keys(context.query).length !== 0) {
+      url += "?" + this.configuration.queryParamsStringify(context.query);
+    }
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    Object.keys(headers).forEach((key) => headers[key] === void 0 ? delete headers[key] : {});
+    const initOverrideFn = typeof initOverrides === "function" ? initOverrides : async () => initOverrides;
+    const initParams = {
+      method: context.method,
+      headers,
+      body: context.body,
+      credentials: this.configuration.credentials
+    };
+    const overriddenInit = {
+      ...initParams,
+      ...await initOverrideFn({
+        init: initParams,
+        context
+      })
+    };
+    let body;
+    if (isFormData(overriddenInit.body) || overriddenInit.body instanceof URLSearchParams || isBlob(overriddenInit.body)) {
+      body = overriddenInit.body;
+    } else if (this.isJsonMime(headers["Content-Type"])) {
+      body = JSON.stringify(overriddenInit.body);
+    } else {
+      body = overriddenInit.body;
+    }
+    const init = {
+      ...overriddenInit,
+      body
+    };
+    return { url, init };
+  }
+  fetchApi = async (url, init) => {
+    let fetchParams = { url, init };
+    for (const middleware of this.middleware) {
+      if (middleware.pre) {
+        fetchParams = await middleware.pre({
+          fetch: this.fetchApi,
+          ...fetchParams
+        }) || fetchParams;
+      }
+    }
+    let response = void 0;
+    try {
+      response = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+    } catch (e) {
+      for (const middleware of this.middleware) {
+        if (middleware.onError) {
+          response = await middleware.onError({
+            fetch: this.fetchApi,
+            url: fetchParams.url,
+            init: fetchParams.init,
+            error: e,
+            response: response ? response.clone() : void 0
+          }) || response;
+        }
+      }
+      if (response === void 0) {
+        if (e instanceof Error) {
+          throw new FetchError(e, "The request failed and the interceptors did not return an alternative response");
+        } else {
+          throw e;
+        }
+      }
+    }
+    for (const middleware of this.middleware) {
+      if (middleware.post) {
+        response = await middleware.post({
+          fetch: this.fetchApi,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone()
+        }) || response;
+      }
+    }
+    return response;
+  };
+  /**
+   * Create a shallow clone of `this` by constructing a new instance
+   * and then shallow cloning data members.
+   */
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+;
+function isBlob(value) {
+  return typeof Blob !== "undefined" && value instanceof Blob;
+}
+function isFormData(value) {
+  return typeof FormData !== "undefined" && value instanceof FormData;
+}
+export class ResponseError extends Error {
+  constructor(response, msg) {
+    super(msg);
+    this.response = response;
+  }
+  name = "ResponseError";
+}
+export class FetchError extends Error {
+  constructor(cause, msg) {
+    super(msg);
+    this.cause = cause;
+  }
+  name = "FetchError";
+}
+export class RequiredError extends Error {
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+  }
+  name = "RequiredError";
+}
+export const COLLECTION_FORMATS = {
+  csv: ",",
+  ssv: " ",
+  tsv: "	",
+  pipes: "|"
+};
+export function exists(json, key) {
+  const value = json[key];
+  return value !== null && value !== void 0;
+}
+export function querystring(params, prefix = "") {
+  return Object.keys(params).map((key) => querystringSingleKey(key, params[key], prefix)).filter((part) => part.length > 0).join("&");
+}
+function querystringSingleKey(key, value, keyPrefix = "") {
+  const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+  if (value instanceof Array) {
+    const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+    return `${encodeURIComponent(fullKey)}=${multiValue}`;
+  }
+  if (value instanceof Set) {
+    const valueAsArray = Array.from(value);
+    return querystringSingleKey(key, valueAsArray, keyPrefix);
+  }
+  if (value instanceof Date) {
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+  }
+  if (value instanceof Object) {
+    return querystring(value, fullKey);
+  }
+  return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+export function mapValues(data, fn) {
+  return Object.keys(data).reduce(
+    (acc, key) => ({ ...acc, [key]: fn(data[key]) }),
+    {}
+  );
+}
+export function canConsumeForm(consumes) {
+  for (const consume of consumes) {
+    if ("multipart/form-data" === consume.contentType) {
+      return true;
+    }
+  }
+  return false;
+}
+export class JSONApiResponse {
+  constructor(raw, transformer = (jsonValue) => jsonValue) {
+    this.raw = raw;
+    this.transformer = transformer;
+  }
+  async value() {
+    return this.transformer(await this.raw.json());
+  }
+}
+export class VoidApiResponse {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return void 0;
+  }
+}
+export class BlobApiResponse {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return await this.raw.blob();
+  }
+}
+export class TextApiResponse {
+  constructor(raw) {
+    this.raw = raw;
+  }
+  async value() {
+    return await this.raw.text();
+  }
+}

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

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

package/dist/runtime/composables/mongocampApi.mjs

@@ -0,0 +1,45 @@
+import {
+  AdminApi,
+  ApplicationApi,
+  AuthApi,
+  BucketApi,
+  CollectionApi,
+  Configuration,
+  DatabaseApi,
+  DocumentApi,
+  FileApi,
+  IndexApi,
+  InformationApi,
+  JobsApi
+} from "../api/index.mjs";
+import { useMongocampUrl } from "./mongocampUrl.mjs";
+import { useMongocampStorage } from "./mongocampStorage.mjs";
+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
+  };
+}

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

@@ -0,0 +1,8 @@
+import type { UserProfile } from '../api';
+export declare function useMongocampAuth(): {
+    login: (loginId: string, loginPassword: string) => Promise<UserProfile>;
+    logout: () => void;
+    isLoggedIn: import("vue").ComputedRef<boolean>;
+    userRoles: import("vue").ComputedRef<string[]>;
+    userGrants: import("vue").ComputedRef<import("../api").Grant[]>;
+};

package/dist/runtime/composables/mongocampAuth.mjs

@@ -0,0 +1,28 @@
+import { computed } from "vue";
+import { useMongocampApi } from "./mongocampApi.mjs";
+import { useMongocampStorage } from "./mongocampStorage.mjs";
+import { useMongocampUser } from "./mongocampUser.mjs";
+export function useMongocampAuth() {
+  const state = useMongocampStorage();
+  const { authApi } = useMongocampApi();
+  const user = useMongocampUser();
+  const login = async (loginId, loginPassword) => {
+    logout();
+    const login2 = { userId: loginId, password: loginPassword };
+    const result = await authApi.login({ login: login2 });
+    state.value.token = result.authToken;
+    state.value.profile = result.userProfile;
+    user.value = result.userProfile;
+    return result.userProfile;
+  };
+  const logout = () => {
+    state.value.token = "";
+    const profile = { user: "", isAdmin: false };
+    state.value.profile = profile;
+    user.value = profile;
+  };
+  const isLoggedIn = computed(() => state.value?.token?.length > 0);
+  const userRoles = computed(() => state.value.profile.roles ?? []);
+  const userGrants = computed(() => state.value.profile.grants ?? []);
+  return { login, logout, isLoggedIn, userRoles, userGrants };
+}

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

@@ -0,0 +1,11 @@
+import type { FindRequest, MongoFindRequest } from '../api';
+export declare function useMongocampSearch(): {
+    mongoFindRequest: (filter?: object, sort?: object, projection?: object) => MongoFindRequest;
+    findRequest: (collection: string, searchParameter?: MongoFindRequest, rows?: number, actualPage?: number) => FindRequest;
+    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<{
+        [key: string]: string;
+    }[]>;
+};

package/dist/runtime/composables/mongocampSearch.mjs

@@ -0,0 +1,20 @@
+import { useRuntimeConfig } from "#app";
+import { useMongocampApi } from "./mongocampApi.mjs";
+export function useMongocampSearch() {
+  const { documentApi } = useMongocampApi();
+  const config = useRuntimeConfig();
+  const mongoFindRequest = (filter = {}, sort = {}, projection = {}) => {
+    return { filter, sort, projection };
+  };
+  const findRequest = (collection, searchParameter = mongoFindRequest(), rows = config.public.mongocamp?.paginationSize, actualPage = 1) => {
+    return { collectionName: collection, mongoFindRequest: searchParameter, rowsPerPage: rows, page: actualPage };
+  };
+  function findAll(collectionName, page = 1, sort = void 0, projection = void 0, rowsPerPage = config.public.mongocamp?.paginationSize) {
+    return documentApi.listDocuments({ collectionName, sort, projection, page, rowsPerPage });
+  }
+  function findByField(collectionName, field, value, page = 1, sort = void 0, projection = void 0, rowsPerPage = config.public.mongocamp?.paginationSize) {
+    const expression = `${field}: ${value}`;
+    return documentApi.listDocuments({ collectionName, filter: expression, sort, projection, page, rowsPerPage });
+  }
+  return { mongoFindRequest, findRequest, findAll, findByField };
+}

package/dist/runtime/composables/mongocampStorage.mjs

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

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

@@ -0,0 +1 @@
+export declare function useMongocampUrl(): string;

package/dist/runtime/composables/mongocampUrl.mjs

@@ -0,0 +1,5 @@
+import { useRuntimeConfig } from "#app";
+export function useMongocampUrl() {
+  const config = useRuntimeConfig();
+  return config.public.mongocamp?.url;
+}

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

@@ -0,0 +1,3 @@
+import type { Ref } from 'vue';
+import type { UserProfile } from '../api';
+export declare function useMongocampUser(): Ref<UserProfile>;

package/dist/runtime/composables/mongocampUser.mjs

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

package/dist/types.d.mts

@@ -0,0 +1,15 @@
+
+import { ModuleOptions } from './module'
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig { ['mongocamp']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['mongocamp']?: ModuleOptions }
+}
+
+declare module 'nuxt/schema' {
+  interface NuxtConfig { ['mongocamp']?: Partial<ModuleOptions> }
+  interface NuxtOptions { ['mongocamp']?: ModuleOptions }
+}
+
+
+export { ModuleOptions, default } from './module'

package/dist/types.d.ts

@@ -1,21 +1,15 @@
 
-import { ModuleOptions, ModuleHooks, ModuleRuntimeConfig, ModulePublicRuntimeConfig } from './module'
+import { ModuleOptions } from './module'
 
 declare module '@nuxt/schema' {
   interface NuxtConfig { ['mongocamp']?: Partial<ModuleOptions> }
   interface NuxtOptions { ['mongocamp']?: ModuleOptions }
-  interface NuxtHooks extends ModuleHooks {}
-  interface RuntimeConfig extends ModuleRuntimeConfig {}
-  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
 }
 
 declare module 'nuxt/schema' {
   interface NuxtConfig { ['mongocamp']?: Partial<ModuleOptions> }
   interface NuxtOptions { ['mongocamp']?: ModuleOptions }
-  interface NuxtHooks extends ModuleHooks {}
-  interface RuntimeConfig extends ModuleRuntimeConfig {}
-  interface PublicRuntimeConfig extends ModulePublicRuntimeConfig {}
 }
 
 
-export { default } from './module'
+export { ModuleOptions, default } from './module'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sfxcode/nuxt-mongocamp-server",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -9,7 +9,7 @@
       "require": "./dist/module.cjs"
     }
   },
-  "main": "dist/module.cjs",
+  "main": "./dist/module.cjs",
   "types": "./dist/types.d.ts",
   "files": [
     "dist"
@@ -18,24 +18,25 @@
     "failOnWarn": false
   },
   "dependencies": {
-    "@nuxt/kit": "^3.6.5",
-    "@vueuse/nuxt": "^10.3.0"
+    "@nuxt/kit": "^3.8.1",
+    "@vueuse/nuxt": "^10.5.0"
   },
   "devDependencies": {
-    "@iconify-json/mdi": "^1.1.53",
-    "@nuxt/module-builder": "^0.4.0",
-    "@nuxtjs/eslint-config-typescript": "12.0.0",
+    "@iconify-json/mdi": "^1.1.55",
+    "@nuxt/module-builder": "^0.5.3",
+    "@nuxtjs/eslint-config-typescript": "12.1.0",
     "@openapitools/openapi-generator-cli": "^2.7.0",
-    "@types/node": "^20.4.5",
-    "@unocss/nuxt": "^0.54.0",
-    "defu": "^6.1.2",
-    "jiti": "^1.19.1",
-    "nuxt": "^3.6.5"
+    "@types/node": "^20.8.10",
+    "@unocss/nuxt": "^0.57.2",
+    "defu": "^6.1.3",
+    "jiti": "^1.21.0",
+    "nuxt": "^3.8.1"
   },
   "scripts": {
-    "dev": "nuxi dev --port 3333 playground",
+    "dev": "nuxi dev playground",
     "dev:build": "nuxi build playground",
     "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground",
+    "dev:start": "node playground/.output/server/index.mjs",
     "lint:show": "eslint ./src/runtime",
     "lint:fix": "eslint --fix ./src/runtime",
     "api-codegen": "openapi-generator-cli generate -i http://173.249.2.248:30103/docs/docs.yaml -g typescript-fetch -o src/runtime/api --additional-properties=typescriptThreePlus=true,supportsES6=true"