@sfxcode/nuxt-mongocamp-server 0.7.0

package/dist/runtime/api/runtime.mjs

@@ -0,0 +1,196 @@
+export const BASE_PATH = "http://localhost".replace(/\/+$/, "");
+const isBlob = (value) => typeof Blob !== "undefined" && value instanceof Blob;
+export class BaseAPI {
+  constructor(configuration = new Configuration()) {
+    this.configuration = configuration;
+    this.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 = await (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+      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;
+    };
+    this.middleware = configuration.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);
+  }
+  async request(context, initOverrides) {
+    const { url, init } = this.createFetchParams(context, initOverrides);
+    const response = await this.fetchApi(url, init);
+    if (response.status >= 200 && response.status < 300) {
+      return response;
+    }
+    throw response;
+  }
+  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 body = typeof FormData !== "undefined" && context.body instanceof FormData || context.body instanceof URLSearchParams || isBlob(context.body) ? context.body : JSON.stringify(context.body);
+    const headers = Object.assign({}, this.configuration.headers, context.headers);
+    const init = {
+      method: context.method,
+      headers,
+      body,
+      credentials: this.configuration.credentials,
+      ...initOverrides
+    };
+    return { url, init };
+  }
+  clone() {
+    const constructor = this.constructor;
+    const next = new constructor(this.configuration);
+    next.middleware = this.middleware.slice();
+    return next;
+  }
+}
+;
+export class RequiredError extends Error {
+  constructor(field, msg) {
+    super(msg);
+    this.field = field;
+    this.name = "RequiredError";
+  }
+}
+export const COLLECTION_FORMATS = {
+  csv: ",",
+  ssv: " ",
+  tsv: "	",
+  pipes: "|"
+};
+export class Configuration {
+  constructor(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 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) => {
+    const fullKey = prefix + (prefix.length ? `[${key}]` : key);
+    const value = params[key];
+    if (value instanceof Array) {
+      const multiValue = value.map((singleValue) => encodeURIComponent(String(singleValue))).join(`&${encodeURIComponent(fullKey)}=`);
+      return `${encodeURIComponent(fullKey)}=${multiValue}`;
+    }
+    if (value instanceof Date) {
+      return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+    }
+    if (value instanceof Object) {
+      return querystring(value, fullKey);
+    }
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+  }).filter((part) => part.length > 0).join("&");
+}
+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 (consume.contentType === "multipart/form-data") {
+      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 const 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";
+import { useMongocampUrl } from "./mongocampUrl.mjs";
+import { useMongocampToken } from "./mongocampToken.mjs";
+export const useMongocampApi = () => {
+  const url = useMongocampUrl();
+  const token = useMongocampToken();
+  const configuration = new Configuration({ basePath: url, accessToken: token.value });
+  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,9 @@
+import type { UserProfile } from '../api';
+export declare const useMongocampAuth: () => {
+    login: (loginId: string, loginPassword: string) => Promise<UserProfile>;
+    logout: () => void;
+    userProfile: () => Promise<UserProfile>;
+    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,52 @@
+import { useMongocampApi } from "./mongocampApi.mjs";
+import { useMongocampToken } from "./mongocampToken.mjs";
+import { useMongocampUser } from "./mongocampUser.mjs";
+import { computed } from "vue";
+export const useMongocampAuth = () => {
+  const token = useMongocampToken();
+  const user = useMongocampUser();
+  const { authApi } = useMongocampApi();
+  const setToken = (value) => {
+    token.value = value;
+  };
+  const setUser = (value) => {
+    user.value = value;
+  };
+  const login = async (loginId, loginPassword) => {
+    setToken(null);
+    const login2 = { userId: loginId, password: loginPassword };
+    const result = await authApi.login({ login: login2 });
+    setToken(result.authToken);
+    setUser(result.userProfile);
+    return result.userProfile;
+  };
+  const logout = () => {
+    setToken(null);
+    setUser(null);
+  };
+  const userProfile = async () => {
+    if (token.value && !user.value) {
+      try {
+        const profile = await authApi.userProfile();
+        setUser(profile);
+      } catch (e) {
+        setToken(null);
+      }
+    }
+    return user.value;
+  };
+  const isLoggedIn = computed(() => token.value != null && user.value != null);
+  const userRoles = computed(() => {
+    if (user.value)
+      return user.value.roles;
+    else
+      return [];
+  });
+  const userGrants = computed(() => {
+    if (user.value)
+      return user.value.grants;
+    else
+      return [];
+  });
+  return { login, logout, userProfile, isLoggedIn, userRoles, userGrants };
+};

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

@@ -0,0 +1,6 @@
+import type { FindRequest } from '../api';
+import { MongoFindRequest } from "../api";
+export declare const useMongocampSearch: () => {
+    createFindRequest: (collection: string, searchParameter?: MongoFindRequest, rows?: any, actualPage?: number) => FindRequest;
+    createSearchParameter: (filter?: object, sort?: object, projection?: object) => MongoFindRequest;
+};

package/dist/runtime/composables/mongocampSearch.mjs

@@ -0,0 +1,12 @@
+import { useRuntimeConfig } from "#app";
+export const useMongocampSearch = () => {
+  const config = useRuntimeConfig();
+  const createFindRequest = (collection, searchParameter = createSearchParameter(), rows = config.mongocamp?.paginationSize, actualPage = 1) => {
+    const result = { collectionName: collection, mongoFindRequest: searchParameter, rowsPerPage: rows, page: actualPage };
+    return result;
+  };
+  const createSearchParameter = (filter = {}, sort = {}, projection = {}) => {
+    return { filter, sort, projection };
+  };
+  return { createFindRequest, createSearchParameter };
+};

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

@@ -0,0 +1 @@
+export declare const useMongocampToken: () => any;

package/dist/runtime/composables/mongocampToken.mjs

@@ -0,0 +1,10 @@
+import { useCookie, useNuxtApp } from "#app";
+export const useMongocampToken = () => {
+  const nuxtApp = useNuxtApp();
+  nuxtApp._cookies = nuxtApp._cookies || {};
+  if (nuxtApp._cookies.mongocamp_token)
+    return nuxtApp._cookies.mongocamp_token;
+  const cookie = useCookie("mongocamp_token");
+  nuxtApp._cookies.mongocamp_token = cookie;
+  return cookie;
+};

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

@@ -0,0 +1 @@
+export declare const useMongocampUrl: () => string;

package/dist/runtime/composables/mongocampUrl.mjs

@@ -0,0 +1,5 @@
+import { useRuntimeConfig } from "#app";
+export const useMongocampUrl = () => {
+  const config = useRuntimeConfig();
+  return config.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 const useMongocampUser: () => Ref<UserProfile>;

package/dist/runtime/composables/mongocampUser.mjs

@@ -0,0 +1,2 @@
+import { useState } from "#app";
+export const useMongocampUser = () => useState("mongocamp.user");

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugin.mjs

@@ -0,0 +1,6 @@
+import { useMongocampAuth } from "./composables/mongocampAuth.mjs";
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin(async (nuxtApp) => {
+  const { userProfile } = useMongocampAuth();
+  await userProfile();
+});

package/dist/types.d.ts

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

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@sfxcode/nuxt-mongocamp-server",
+  "version": "0.7.0",
+  "license": "MIT",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/module.mjs",
+      "require": "./dist/module.cjs"
+    }
+  },
+  "main": "./dist/module.cjs",
+  "types": "./dist/types.d.ts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@antfu/eslint-config": "^0.27.0",
+    "@iconify-json/mdi": "^1.1.33",
+    "@nuxt/kit": "^3.0.0-rc.11",
+    "@nuxt/module-builder": "latest",
+    "@openapitools/openapi-generator-cli": "^2.5.2",
+    "@types/node": "^18.7.23",
+    "@unocss/nuxt": "^0.45.26",
+    "defu": "^6.1.0",
+    "jiti": "^1.16.0",
+    "nuxt": "^3.0.0-rc.11"
+  },
+  "scripts": {
+    "dev": "nuxi dev --port 3333 playground",
+    "dev:build": "nuxi build playground",
+    "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground",
+    "lint:show": "eslint ./src/runtime",
+    "lint:fix": "eslint --fix ./src/runtime",
+    "api-codegen": "openapi-generator-cli generate -i http://localhost:3000/docs/docs.yaml -g typescript-fetch -o src/runtime/api --additional-properties=typescriptThreePlus=true,supportsES6=true"
+  }
+}