fix(module): fixed linting

Intevel · Oct 6, 2022 · 5814b41 · 5814b41
1 parent 5baa129
commit 5814b41
Show file tree

Hide file tree

Showing 12 changed files with 208 additions and 21,037 deletions.
diff --git a/package-lock.json b/package-lock.json
diff --git a/src/runtime/composables/useDirectus.ts b/src/runtime/composables/useDirectus.ts
@@ -1,22 +1,22 @@
-import type { FetchError, FetchOptions } from "ohmyfetch";
-import { useNuxtApp, useRuntimeConfig } from "#app";
-import { useDirectusUrl } from "./useDirectusUrl";
-import { useDirectusToken } from "./useDirectusToken";
+import type { FetchError, FetchOptions } from 'ohmyfetch'
+import { useDirectusUrl } from './useDirectusUrl'
+import { useDirectusToken } from './useDirectusToken'
+import { useNuxtApp, useRuntimeConfig } from '#app'
 
 export const useDirectus = () => {
-  const nuxt = useNuxtApp();
-  const baseURL = useDirectusUrl();
+  const nuxt = useNuxtApp()
+  const baseURL = useDirectusUrl()
   const config = useRuntimeConfig()
-  var token = useDirectusToken();
-  
+  const token = useDirectusToken()
+
   return async <T>(
     url: string,
     fetchOptions: FetchOptions = {}
   ): Promise<T> => {
-    const headers: HeadersInit = {};
+    const headers: HeadersInit = {}
 
     if (token && token.value) {
-      headers.Authorization = `Bearer ${token.value}`;
+      headers.Authorization = `Bearer ${token.value}`
     } else if (config.directus.token) {
       headers.Authorization = `Bearer ${config.directus.token}`
     }
@@ -27,11 +27,11 @@ export const useDirectus = () => {
         ...fetchOptions,
         headers: {
           ...headers,
-          ...fetchOptions.headers,
-        },
-      });
+          ...fetchOptions.headers
+        }
+      })
     } catch (err: any) {
-      console.error("[Directus Error]: " + err);
+      console.error('[Directus Error]: ' + err)
     }
-  };
-};
+  }
+}
diff --git a/src/runtime/composables/useDirectusAuth.ts b/src/runtime/composables/useDirectusAuth.ts
@@ -1,125 +1,125 @@
-import type { Ref } from "vue";
+import type { Ref } from 'vue'
 import type {
   DirectusAuthResponse,
   DirectusAuthCredentials,
   DirectusUser,
   DirectusPasswordForgotCredentials,
   DirectusPasswordResetCredentials,
-  DirectusRegisterCredentials,
-} from "../types";
-import { useDirectus } from "./useDirectus";
-import { useDirectusUser } from "./useDirectusUser";
-import { useDirectusUrl } from "./useDirectusUrl";
-import { useDirectusToken } from "./useDirectusToken";
-import { useRuntimeConfig } from "#app";
+  DirectusRegisterCredentials
+} from '../types'
+import { useDirectus } from './useDirectus'
+import { useDirectusUser } from './useDirectusUser'
+import { useDirectusUrl } from './useDirectusUrl'
+import { useDirectusToken } from './useDirectusToken'
+import { useRuntimeConfig } from '#app'
 
 export const useDirectusAuth = () => {
-  const url = useDirectusUrl();
-  const config = useRuntimeConfig();
-  const directus = useDirectus();
-  const user = useDirectusUser();
-  const token = useDirectusToken();
+  const url = useDirectusUrl()
+  const config = useRuntimeConfig()
+  const directus = useDirectus()
+  const user = useDirectusUser()
+  const token = useDirectusToken()
 
   const setToken = (value: string | null) => {
-    token.value = value;
-  };
+    token.value = value
+  }
 
   const setUser = (value: DirectusUser) => {
-    user.value = value;
-  };
+    user.value = value
+  }
 
   const fetchUser = async (): Promise<Ref<DirectusUser>> => {
     if (token.value && !user.value) {
       try {
         if (config.directus.fetchUserParams?.filter) {
           (config.directus.fetchUserParams.filter as unknown) = JSON.stringify(
             config.directus.fetchUserParams.filter
-          );
+          )
         }
         if (config.directus.fetchUserParams?.deep) {
           (config.directus.fetchUserParams.deep as unknown) = JSON.stringify(
             config.directus.fetchUserParams.deep
-          );
+          )
         }
         if (config.directus.fetchUserParams) {
-          var res = await directus<{ data: DirectusUser }>("/users/me", {
-            params: config.directus.fetchUserParams,
-          });
+          var res = await directus<{ data: DirectusUser }>('/users/me', {
+            params: config.directus.fetchUserParams
+          })
         } else {
-          var res = await directus<{ data: DirectusUser }>("/users/me");
+          var res = await directus<{ data: DirectusUser }>('/users/me')
         }
-        setUser(res.data);
+        setUser(res.data)
       } catch (e) {
-        setToken(null);
+        setToken(null)
       }
     }
-    return user;
-  };
+    return user
+  }
 
   const login = async (
     data: DirectusAuthCredentials
   ): Promise<DirectusAuthResponse> => {
-    setToken(null);
+    setToken(null)
 
     const response: { data: DirectusAuthResponse } = await directus(
-      "/auth/login",
+      '/auth/login',
       {
-        method: "POST",
-        body: data,
+        method: 'POST',
+        body: data
       }
-    );
+    )
 
-    if(!response.data.access_token)  throw new Error("Login failed, please check your credentials.")
-    setToken(response.data.access_token);
+    if (!response.data.access_token) { throw new Error('Login failed, please check your credentials.') }
+    setToken(response.data.access_token)
 
-    const user = await fetchUser();
+    const user = await fetchUser()
 
     return {
       user,
       access_token: response.data.access_token,
-      expires: response.data.expires,
-    };
-  };
+      expires: response.data.expires
+    }
+  }
 
   const createUser = async (
     data: DirectusRegisterCredentials
   ): Promise<DirectusUser> => {
-    return await directus("/users", {
-      method: "POST",
-      body: data,
-    });
-  };
+    return await directus('/users', {
+      method: 'POST',
+      body: data
+    })
+  }
 
   // Alias for createUser
   const register = async (
     data: DirectusRegisterCredentials
   ): Promise<DirectusUser> => {
-    return createUser(data);
-  };
+    return createUser(data)
+  }
 
   const requestPasswordReset = async (
     data: DirectusPasswordForgotCredentials
   ): Promise<void> => {
-    await directus("/auth/password/request", {
-      method: "POST",
-      body: data,
-    });
-  };
+    await directus('/auth/password/request', {
+      method: 'POST',
+      body: data
+    })
+  }
 
   const resetPassword = async (
     data: DirectusPasswordResetCredentials
   ): Promise<void> => {
-    await directus("/auth/password/reset", {
-      method: "POST",
-      body: data,
-    });
-  };
+    await directus('/auth/password/reset', {
+      method: 'POST',
+      body: data
+    })
+  }
 
   const logout = (): void => {
     // https://docs.directus.io/reference/authentication/#logout todo: implement this
-    setToken(null);
-    setUser(null);
-  };
+    setToken(null)
+    setUser(null)
+  }
 
   return {
     setToken,
@@ -130,6 +130,6 @@ export const useDirectusAuth = () => {
     resetPassword,
     logout,
     createUser,
-    register,
-  };
-};
+    register
+  }
+}
diff --git a/src/runtime/composables/useDirectusCollections.ts b/src/runtime/composables/useDirectusCollections.ts
@@ -2,79 +2,79 @@ import {
   DirectusCollectionCreation,
   DirectusCollectionMeta,
   DirectusCollectionRequest,
-  DirectusCollectionUpdate,
-} from "../types";
+  DirectusCollectionUpdate
+} from '../types'
 
-import { useDirectus } from "./useDirectus";
-import { useDirectusUrl } from "./useDirectusUrl";
+import { useDirectus } from './useDirectus'
+import { useDirectusUrl } from './useDirectusUrl'
 
 export const useDirectusCollections = () => {
-  const directusUrl = useDirectusUrl();
-  const directus = useDirectus();
+  const directusUrl = useDirectusUrl()
+  const directus = useDirectus()
 
   const getCollections = async <T>(): Promise<T[]> => {
-    const collections = await directus<{ data: T[] }>("/collections/", {
-      method: "GET",
-    });
-    return collections.data;
-  };
+    const collections = await directus<{ data: T[] }>('/collections/', {
+      method: 'GET'
+    })
+    return collections.data
+  }
 
   const getCollection = async <T>(
     data: DirectusCollectionRequest
   ): Promise<T> => {
-    let connectionName = "";
+    let connectionName = ''
 
     if (data.name) {
-      connectionName = data.name;
+      connectionName = data.name
     }
 
     const collection = await directus<{ data: T }>(
       `/collections/${connectionName}`,
       {
-        method: "GET",
+        method: 'GET'
       }
-    );
-    return collection.data;
-  };
+    )
+    return collection.data
+  }
 
   const createCollection = async <T>(
     data: DirectusCollectionCreation
   ): Promise<T> => {
-    const collection = await directus<{ data: T }>("/collections", {
-      method: "POST",
-      body: data,
-    });
-    return collection.data;
-  };
+    const collection = await directus<{ data: T }>('/collections', {
+      method: 'POST',
+      body: data
+    })
+    return collection.data
+  }
 
   const updateCollection = async <T>(
     data: DirectusCollectionUpdate
   ): Promise<T> => {
     const collection = await directus<{ data: T }>(
       `/collections/${data.name}`,
       {
-        method: "PATCH",
+        method: 'PATCH',
         body: {
-          meta: data.meta,
-        },
+          meta: data.meta
+        }
       }
-    );
-    return collection.data;
-  };
+    )
+    return collection.data
+  }
 
   const deleteCollection = async <T>(
     data: DirectusCollectionRequest
   ): Promise<void> => {
     await directus<{ data: T }>(`/collections/${data.name}`, {
-      method: "DELETE",
-    });
-  };
+      method: 'DELETE'
+    })
+  }
 
   return {
     getCollections,
     getCollection,
     createCollection,
     updateCollection,
-    deleteCollection,
-  };
-};
+    deleteCollection
+  }
+}