@tanglemedia/svelte-starter-directus-api 0.0.15 → 0.1.0

package/src/services/auth.ts

@@ -0,0 +1,82 @@
+import type { AuthenticationClient } from '@directus/sdk';
+import { readMe, refresh, updateMe } from '@directus/sdk';
+import type { DirectusClient, RestClient } from '@directus/sdk';
+import { ServiceAdapterAbstract } from '@tanglemedia/svelte-starter-core';
+
+class DirectusAuthServices extends ServiceAdapterAbstract {
+  public getDirectus() {
+    return this.getAdapterClient<
+      DirectusClient<object> & RestClient<object> & AuthenticationClient<object>
+    >();
+  }
+
+  // public getConfig<T extends object>(): DirectusClient<T> & RestClient<object> {
+  //   return this.directus as DirectusClient<T> & RestClient<object>;
+  // }
+
+  public async refresh<T>(): Promise<T> {
+    try {
+      const response = await (await this.getDirectus()).request<T>(refresh());
+      return response;
+    } catch (error) {
+      console.error(`Error refreshing :`, error);
+      throw error;
+    }
+  }
+
+  public async getToken() {
+    try {
+      const response = await (await this.getDirectus()).getToken();
+      return response;
+    } catch (error) {
+      console.error(`Error refreshing :`, error);
+      throw error;
+    }
+  }
+
+  public async login(email: string, password: string) {
+    try {
+      const response = await (await this.getDirectus()).login(email, password);
+      return response;
+    } catch (error) {
+      console.error(`Error login :`, error);
+      throw error;
+    }
+  }
+
+  public async logout() {
+    try {
+      const response = await (await this.getDirectus()).logout();
+      return response;
+    } catch (error) {
+      console.error(`Error refreshing :`, error);
+      throw error;
+    }
+  }
+
+  public async getCurrentUser<T>(fields: string[] | null = null): Promise<T> {
+    try {
+      if (!this.getToken()) await this.refresh();
+      const response = await (
+        await this.getDirectus()
+      ).request<T>(readMe({ fields: fields ? fields : ['*', 'roles.*'] }));
+      return response;
+    } catch (error) {
+      console.error(`Error refreshing :`, error);
+      throw error;
+    }
+  }
+
+  public async updateCurrentUser<T>(data: object): Promise<T> {
+    try {
+      if (!this.getToken()) await this.refresh();
+      const response = await (await this.getDirectus()).request<T>(updateMe(data));
+      return response;
+    } catch (error) {
+      console.error(`Error refreshing :`, error);
+      throw error;
+    }
+  }
+}
+
+export { DirectusAuthServices };

package/src/services/register.ts

@@ -0,0 +1,28 @@
+import { createUser } from '@directus/sdk';
+import type { AuthenticationClient, DirectusClient, RestClient } from '@directus/sdk';
+import { ServiceAdapterAbstract } from '@tanglemedia/svelte-starter-core';
+
+class DirectusStaticServices extends ServiceAdapterAbstract {
+  public getDirectus() {
+    return this.getAdapterClient<
+      DirectusClient<object> & RestClient<object> & AuthenticationClient<object>
+    >();
+  }
+
+  public async createUser(
+    data:
+      | { email: string; password: string; first_name: string; last_name: string; role: string }
+      | object
+  ): Promise<{ message: string; type: string }> {
+    try {
+      await (await this.getDirectus()).request(createUser(data));
+
+      return { message: 'You have successfully registered your account', type: 'success' };
+    } catch (error) {
+      console.error(`Error creating a user:`, error);
+      throw error;
+    }
+  }
+}
+
+export { DirectusStaticServices };

package/src/static.deprecated.ts

@@ -0,0 +1,77 @@
+import { createDirectus, createUser, rest, staticToken } from '@directus/sdk';
+import type { DirectusClient, RestClient, StaticTokenClient } from '@directus/sdk';
+import type { AnyObject, BaseApiAdapterConfig } from '@tanglemedia/svelte-starter-core';
+
+type BaseApiMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+class ApiStaticDirectus {
+  private baseURL: string;
+  private directusAccessToken: string;
+  private directus: DirectusClient<AnyObject> & RestClient<object> & StaticTokenClient<object>;
+
+  constructor(baseURL: string, directusAccessToken: string) {
+    this.baseURL = baseURL;
+    this.directusAccessToken = directusAccessToken;
+    this.init();
+  }
+
+  private init<T extends object>(): void {
+    try {
+      this.directus = createDirectus<T>(this.baseURL)
+        .with(rest())
+        .with(staticToken(this.directusAccessToken));
+    } catch (error) {
+      console.error(`Error initializing Directus admin:`, error);
+      throw error;
+    }
+  }
+
+  public getConfig<T extends object>(configuration?: unknown): BaseApiAdapterConfig {
+    // return this.directus as DirectusClient<T> & RestClient<object>;
+    const client = this.directus as DirectusClient<T> & RestClient<object>;
+
+    // Add the 'configuration' property to the returned object
+    const config: BaseApiAdapterConfig = {
+      configuration: configuration ?? {} // Use the provided configuration or an empty object if not provided
+    };
+
+    return Object.assign(client, config);
+  }
+
+  public async request<T>(
+    method: BaseApiMethods,
+    url: string,
+    query?: Record<string, unknown>
+  ): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(() => {
+        const params = JSON.stringify(query);
+        return {
+          path: `${url}?${params}`,
+          method: method
+        };
+      });
+      return response;
+    } catch (error) {
+      console.error(`Error request:`, error);
+      throw error;
+    }
+  }
+
+  public async createUser(
+    data:
+      | { email: string; password: string; first_name: string; last_name: string; role: string }
+      | object
+  ): Promise<{ message: string; type: string }> {
+    try {
+      await this.directus.request(createUser(data));
+
+      return { message: 'You have successfully registered your account', type: 'success' };
+    } catch (error) {
+      console.error(`Error creating a user:`, error);
+      throw error;
+    }
+  }
+}
+
+export { ApiStaticDirectus };

package/src/storage/local-storage.ts

@@ -0,0 +1,33 @@
+import type { AuthenticationStorage, AuthenticationData } from '@directus/sdk';
+import { BROWSER } from 'esm-env';
+import { LocalStoragePolyFill } from '@tanglemedia/svelte-starter-core';
+
+const loadStorage = () => {
+  return BROWSER && window && window.localStorage
+    ? window.localStorage
+    : (new LocalStoragePolyFill() as Storage);
+};
+
+export class AuthLocalStorage implements AuthenticationStorage {
+  #storage = loadStorage();
+
+  constructor(private readonly storageKey: string = 'access_token_directus') {}
+
+  get key() {
+    return this.storageKey;
+  }
+
+  // get: () => a | Promise<a | null> | null;
+  async get(): Promise<AuthenticationData | null> {
+    const data = this.#storage.getItem(this.key);
+    return data ? (JSON.parse(data) as AuthenticationData) : null;
+  }
+
+  async set(value: AuthenticationData | null) {
+    if (value === null) {
+      this.#storage.removeItem(this.key);
+    } else {
+      this.#storage.setItem(this.key, JSON.stringify(value));
+    }
+  }
+}

package/src/types/adapter.types.ts

@@ -0,0 +1,30 @@
+import type { AuthenticationMode, GraphqlConfig } from '@directus/sdk';
+import type { BaseApiAdapterConfig } from '@tanglemedia/svelte-starter-core';
+
+export type DirectusApiAuthOptions = {
+  mode: AuthenticationMode;
+  config?: Partial<{
+    autoRefresh: boolean;
+    msRefreshBeforeExpires: number;
+    credentials?: RequestCredentials;
+    storage?: 'localStorage' | 'memoryStorage';
+  }>;
+};
+
+export type DirectusApiAdapterOptions = {
+  protocol?: 'http' | 'https';
+  host?: string | null;
+
+  auth?: DirectusApiAuthOptions;
+  staticToken?: string;
+
+  graphql?: GraphqlConfig;
+
+  rest?: {
+    credentials?: RequestCredentials;
+  };
+};
+
+export type DirectusConfig = BaseApiAdapterConfig<DirectusApiAdapterOptions>;
+
+export type SchemaShape = Record<string, object>;

package/src/types/index.ts

@@ -0,0 +1 @@
+export * from './adapter.types';

package/dist/static.d.ts

@@ -1,31 +0,0 @@
-import type { AnyObject, ApiAdapterInterface, ApiAdapterRequestConfig, BaseApiAdapterConfig } from '@tanglemedia/svelte-starter-core';
-type BaseApiMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-type ApiId = string | number;
-declare class ApiStaticDirectus implements ApiAdapterInterface {
-    private baseURL;
-    private directusAccessToken;
-    private directus;
-    constructor(baseURL: string, directusAccessToken: string);
-    private init;
-    getConfig<T extends object>(configuration?: unknown): BaseApiAdapterConfig;
-    request<T>(method: BaseApiMethods, url: string, query?: Record<string, unknown>): Promise<T>;
-    createUser(data: {
-        email: string;
-        password: string;
-        first_name: string;
-        last_name: string;
-        role: string;
-    } | object): Promise<{
-        message: string;
-        type: string;
-    }>;
-    find<T>(collection: string, query?: Record<string, unknown>): Promise<T>;
-    findOne<T>(collection: string, key: ApiId, query?: Record<string, unknown>): Promise<T>;
-    aggregate<T>(collection: string, query?: Record<string, unknown>): Promise<T>;
-    patch<T>(collection: string, key: ApiId, query?: Record<string, unknown>): Promise<T>;
-    post<T>(collection: string, data: AnyObject, query?: Record<string, unknown>): Promise<T>;
-    delete<T>(collection: string, keys: ApiId): Promise<T>;
-    put<T>(collection: string, payload: AnyObject, config?: ApiAdapterRequestConfig, key?: ApiId): Promise<T>;
-    upload<T>(path: string | undefined, data: FormData): Promise<T>;
-}
-export { ApiStaticDirectus };

package/dist/static.js

@@ -1,151 +0,0 @@
-import { aggregate, createDirectus, createItem, createUser, deleteItem, readItem, readItems, rest, staticToken, updateItem, updateItems, uploadFiles } from '@directus/sdk';
-class ApiStaticDirectus {
-    baseURL;
-    directusAccessToken;
-    directus;
-    constructor(baseURL, directusAccessToken) {
-        this.baseURL = baseURL;
-        this.directusAccessToken = directusAccessToken;
-        this.init();
-    }
-    init() {
-        try {
-            this.directus = createDirectus(this.baseURL)
-                .with(rest())
-                .with(staticToken(this.directusAccessToken));
-        }
-        catch (error) {
-            console.error(`Error initializing Directus admin:`, error);
-            throw error;
-        }
-    }
-    getConfig(configuration) {
-        // return this.directus as DirectusClient<T> & RestClient<object>;
-        const client = this.directus;
-        // Add the 'configuration' property to the returned object
-        const config = {
-            configuration: configuration ?? {} // Use the provided configuration or an empty object if not provided
-        };
-        return Object.assign(client, config);
-    }
-    async request(method, url, query) {
-        try {
-            const response = await this.directus.request(() => {
-                const params = JSON.stringify(query);
-                return {
-                    path: `${url}?${params}`,
-                    method: method
-                };
-            });
-            return response;
-        }
-        catch (error) {
-            console.error(`Error request:`, error);
-            throw error;
-        }
-    }
-    async createUser(data) {
-        try {
-            await this.directus.request(createUser(data));
-            return { message: 'You have successfully registered your account', type: 'success' };
-        }
-        catch (error) {
-            console.error(`Error creating a user:`, error);
-            throw error;
-        }
-    }
-    async find(collection, query) {
-        try {
-            const response = await this.directus.request(readItems(collection, query));
-            return response;
-        }
-        catch (error) {
-            console.error(`Error fetching all ${collection}:`, error);
-            throw error;
-        }
-    }
-    async findOne(collection, key, query) {
-        try {
-            const response = await this.directus.request(readItem(collection, key, query));
-            return response;
-        }
-        catch (error) {
-            console.error(`Error fetching ${collection}:`, error);
-            throw error;
-        }
-    }
-    async aggregate(collection, query) {
-        try {
-            const response = await this.directus.request(aggregate(collection, {
-                aggregate: {
-                    count: 'id'
-                },
-                query
-            }));
-            return response;
-        }
-        catch (error) {
-            console.error(`Error fetching total of ${collection}:`, error);
-            throw error;
-        }
-    }
-    async patch(collection, key, query) {
-        try {
-            const response = await this.directus.request(updateItems(collection, key, query));
-            return response;
-        }
-        catch (error) {
-            console.error(`Error updating all ${collection}:`, error);
-            throw error;
-        }
-    }
-    async post(collection, data, query) {
-        try {
-            const response = await this.directus.request(createItem(collection, data, query));
-            return response;
-        }
-        catch (error) {
-            console.error(`Error creating items ${collection}:`, error);
-            throw error;
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async delete(collection, keys) {
-        try {
-            const response = await this.directus.request(deleteItem(collection, key));
-            return response;
-        }
-        catch (error) {
-            console.error(`Error deleting items ${collection}:`, error);
-            throw error;
-        }
-    }
-    async put(collection, payload, config, key) {
-        try {
-            if (key) {
-                const response = await this.directus.request(updateItem(collection, key, payload));
-                return response;
-            }
-            else {
-                console.error(`Error updating all ${collection}: no key specified`);
-                throw new Error('No key specified');
-            }
-        }
-        catch (error) {
-            console.error(`Error updating all ${collection}:`, error);
-            throw error;
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    async upload(path = '', data) {
-        try {
-            const response = await this.directus.request(uploadFiles(data));
-            return response;
-        }
-        catch (error) {
-            console.error(`Error uploading file:`, error);
-            throw error;
-        }
-    }
-}
-export { ApiStaticDirectus };

package/src/client.ts

@@ -1,254 +0,0 @@
-import type { AuthenticationConfig, AuthenticationData } from '@directus/sdk';
-import {
-  aggregate,
-  authentication,
-  createDirectus,
-  createItem,
-  deleteItem,
-  readItem,
-  readItems,
-  rest,
-  updateItem,
-  uploadFiles,
-  memoryStorage
-} from '@directus/sdk';
-import type { DirectusClient, RestClient } from '@directus/sdk';
-import type {
-  AnyObject,
-  ApiAdapterInterface,
-  ApiAdapterRequestConfig,
-  BaseApiAdapterConfig
-} from '@tanglemedia/svelte-starter-core';
-
-import { browser } from '$app/environment';
-
-import cookie from 'js-cookie';
-
-const localDirectusStorage = (storageKey: string = 'access_token_directus') => {
-  if (!browser || !window.localStorage) {
-    console.warn('Defaulting to memory storage');
-    return memoryStorage();
-  }
-
-  const storage = window.localStorage;
-
-  return {
-    get: async (): Promise<AuthenticationData | null> => {
-      const data = storage.getItem(storageKey);
-      return data ? (JSON.parse(data) as AuthenticationData) : null;
-    },
-    set: async (value: AuthenticationData | null): Promise<void> => {
-      if (value === null) {
-        storage.removeItem(storageKey);
-      } else {
-        storage.setItem(storageKey, JSON.stringify(value));
-      }
-    }
-  };
-};
-
-// const cookieDirectusStorage = (cookieKey: string = 'access_token_directus') => {
-//   return {
-//     get: async (): Promise<AuthenticationData | null> => {
-//       const data = JSON.parse(cookie.get(cookieKey)) || '{}';
-//       return data ? (data as AuthenticationData) : null;
-
-//     },
-//     set: async (value: AuthenticationData | null): Promise<void> => {
-//       cookie.set(cookieKey, JSON.stringify(value))
-//     }
-//   };
-// }
-
-const authenticationConfig: AuthenticationConfig = {
-  storage: localDirectusStorage(),
-  autoRefresh: true,
-  msRefreshBeforeExpires: 30000,
-  credentials: 'include'
-};
-
-// const authenticationCookieConfig: AuthenticationConfig = {
-//   storage: cookieDirectusStorage(),
-//   autoRefresh: true,
-//   msRefreshBeforeExpires: 30000,
-//   credentials: 'include'
-// };
-
-type BaseApiMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-
-type ApiId = string | number;
-
-class ApiClientDirectus implements ApiAdapterInterface {
-  private baseURL: string;
-  private storageMode: 'json' | 'cookie';
-  private directus: DirectusClient<object> & RestClient<object>;
-
-  constructor(baseURL: string, storageMode: 'json' | 'cookie' = 'json') {
-    this.baseURL = baseURL;
-    this.storageMode = storageMode;
-    this.init();
-  }
-
-  private init<T extends object>(): void {
-    try {
-      if(this.storageMode === 'json'){
-        this.directus = createDirectus<T>(this.baseURL)
-        .with(rest({ credentials: 'include' }))
-        .with(authentication('json', authenticationConfig));
-      }else {
-        this.directus = createDirectus<T>(this.baseURL)
-        .with(authentication('cookie', { credentials: 'include' }))
-        .with(rest({ credentials: 'include' }));
-      }
-    } catch (error) {
-      console.error(`Error initializing Directus:`, error);
-      throw error;
-    }
-  }
-
-  public getConfig<T extends object>(configuration?: unknown): BaseApiAdapterConfig {
-    // return this.directus as DirectusClient<T> & RestClient<object>;
-    const client = this.directus as DirectusClient<T> & RestClient<object>;
-
-    // Add the 'configuration' property to the returned object
-    const config: BaseApiAdapterConfig = {
-      configuration: configuration ?? {} // Use the provided configuration or an empty object if not provided
-    };
-
-    return Object.assign(client, config);
-  }
-
-  public async request<T>(
-    method: BaseApiMethods,
-    url: string,
-    query?: Record<string, unknown>
-  ): Promise<T> {
-    try {
-      const response = await this.directus.request<T>(() => {
-        const params = JSON.stringify(query);
-        return {
-          path: `${url}?${params}`,
-          method: method
-        };
-      });
-      return response;
-    } catch (error) {
-      console.error(`Error request:`, error);
-      throw error;
-    }
-  }
-
-  public async find<T>(collection: string, query?: Record<string, unknown>): Promise<T> {
-    // console.log('in find');
-    try {
-      // console.log(`Find ${collection}`)
-      const response = await this.directus.request<T>(readItems(collection, query));
-      return response;
-    } catch (error) {
-      console.error(`Error fetching all ${collection}:`, error);
-      throw error;
-    }
-  }
-
-  public async findOne<T>(
-    collection: string,
-    key?: ApiId,
-    query?: Record<string, unknown>
-  ): Promise<T> {
-    try {
-      const response = await this.directus.request<T>(readItem(collection, key, query));
-      return response;
-    } catch (error) {
-      console.error(`Error fetching ${collection}:`, error);
-      throw error;
-    }
-  }
-
-  public async aggregate<T>(collection: string, query?: Record<string, unknown>): Promise<T> {
-    try {
-      const response = await this.directus.request<T>(
-        aggregate(collection, {
-          aggregate: {
-            count: 'id'
-          },
-          query
-        })
-      );
-      return response;
-    } catch (error) {
-      console.error(`Error fetching total of ${collection}:`, error);
-      throw error;
-    }
-  }
-
-  public async patch<T>(
-    collection: string,
-    key: ApiId,
-    query?: Record<string, unknown>
-  ): Promise<T> {
-    try {
-      const response = await this.directus.request<T>(updateItem(collection, key, query));
-      return response;
-    } catch (error) {
-      console.error(`Error updating all ${collection}:`, error);
-      throw error;
-    }
-  }
-
-  public async post<T>(
-    collection: string,
-    data: AnyObject,
-    query?: Record<string, unknown>
-  ): Promise<T> {
-    try {
-      const response = await this.directus.request<T>(createItem(collection, data, query));
-      return response;
-    } catch (error) {
-      console.error(`Error creating items ${collection}:`, error);
-      throw error;
-    }
-  }
-
-  public async delete<T>(collection: string, key?: ApiId): Promise<T> {
-    try {
-      const response = await this.directus.request<T>(deleteItem(collection, key));
-      return response;
-    } catch (error) {
-      console.error(`Error deleting items ${collection}:`, error);
-      throw error;
-    }
-  }
-
-  public async put<T>(
-    collection: string,
-    payload: AnyObject,
-    config?: ApiAdapterRequestConfig,
-    key?: ApiId
-  ): Promise<T> {
-    try {
-      if (key) {
-        const response = await this.directus.request<T>(updateItem(collection, key, payload));
-        return response;
-      } else {
-        console.error(`Error updating all ${collection}: no key specified`);
-        throw new Error('No key specified');
-      }
-    } catch (error) {
-      console.error(`Error updating all ${collection}:`, error);
-      throw error;
-    }
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public async upload<T>(path: string = '', data: FormData): Promise<T> {
-    try {
-      const response = await this.directus.request<T>(uploadFiles(data));
-      return response;
-    } catch (error) {
-      console.error(`Error uploading file:`, error);
-      throw error;
-    }
-  }
-}
-
-export { ApiClientDirectus };