@tanglemedia/svelte-starter-directus-api 0.0.16 → 0.1.1

package/src/provider/directus.factory.ts

@@ -0,0 +1,69 @@
+import {
+  authentication,
+  createDirectus,
+  graphql,
+  rest,
+  staticToken,
+  type AuthenticationConfig,
+  type ClientOptions
+} from '@directus/sdk';
+import { AuthLocalStorage } from '../storage/local-storage';
+import type { DirectusConfig } from '../types/adapter.types';
+
+const authConfigDefaults = {
+  autoRefresh: false,
+  msRefreshBeforeExpires: 0,
+  credentials: 'include' as const
+};
+
+/**
+ * Creates a directus client based on the application configuration
+ */
+export const createDirectusClientFactory = <T extends object>(
+  {
+    baseUrl,
+    configuration: { protocol = 'https', host, auth, staticToken: token, graphql: gql, rest: rs }
+  }: DirectusConfig,
+  options?: ClientOptions
+) => {
+  let url = baseUrl;
+
+  if (host) {
+    url = `${protocol}://${host}`;
+  }
+
+  if (!url) {
+    throw new Error('Unable to resolve base url for directus client');
+  }
+
+  // if there is going to be authentication and no rest config has been specified.
+  // set the correct defaults
+  if (!rs && auth) {
+    rs = { credentials: 'include' };
+  }
+
+  let client = createDirectus<T>(url, options).with(rest(rs));
+
+  if (auth) {
+    const { config: c, mode } = auth;
+    const { storage, ...config } = { ...authConfigDefaults, ...(c || {}) };
+
+    const authConfig: AuthenticationConfig = config;
+
+    if (storage === 'localStorage') {
+      authConfig.storage = new AuthLocalStorage();
+    }
+
+    client = client.with(authentication(mode, authConfig));
+  }
+
+  if (token) {
+    client = client.with(staticToken(token));
+  }
+
+  if (gql) {
+    client = client.with(graphql(gql));
+  }
+
+  return client;
+};

package/src/services/auth.ts

@@ -0,0 +1,92 @@
+import type { AuthenticationClient } from '@directus/sdk';
+import { readFiles, readMe, refresh, updateMe } from '@directus/sdk';
+import type { DirectusClient, RestClient } from '@directus/sdk';
+import { ApiResponse, 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() {
+    try {
+      const response = await (await this.getDirectus()).refresh();
+      return response;
+    } catch (error) {
+      console.error(`Error on directus sdk refresh() :`, error);
+      throw error;
+    }
+  }
+
+  public async getToken() {
+    try {
+      const response = await (await this.getDirectus()).getToken();
+      return response;
+    } catch (error) {
+      console.error(`Error on directus sdk getToken() :`, 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 on directus sdk login() :`, error);
+      throw error;
+    }
+  }
+
+  public async logout() {
+    try {
+      const response = await (await this.getDirectus()).logout();
+      return response;
+    } catch (error) {
+      console.error(`Error on directus sdk logout() :`, error);
+      throw error;
+    }
+  }
+
+  public async getCurrentUser<T>(fields: string[] | null = null): Promise<T> {
+    try {
+      if (!await 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 on directus sdk readMe() :`, error);
+      throw error;
+    }
+  }
+
+  public async updateCurrentUser<T>(data: object): Promise<T> {
+    try {
+      if (!await this.getToken()) await this.refresh();
+      const response = await (await this.getDirectus()).request<T>(updateMe(data));
+      return response;
+    } catch (error) {
+      console.error(`Error on directus sdk updateMe() :`, error);
+      throw error;
+    }
+  }
+
+  public async readFile<T>(query?: Record<string, unknown>): Promise<T> {
+    try {
+      const response = await (await this.getDirectus()).request<T>(readFiles(query));
+      return response;
+    } catch (error) {
+      console.error('Error on directus sdk readFiles():', 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 };