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

package/dist/types/adapter.types.d.ts

@@ -0,0 +1,23 @@
+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/dist/types/adapter.types.js

@@ -0,0 +1 @@
+export {};

package/dist/types/index.d.ts

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

package/dist/types/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanglemedia/svelte-starter-directus-api",
-  "version": "0.0.16",
+  "version": "0.1.0",
   "main": "src/index.ts",
   "types": "src/index.ts",
   "description": "directus API wrapper for all the directus sdk functionality",
@@ -41,7 +41,7 @@
     "@types/js-cookie": "^3.0.6",
     "esm-env": "^1.0.0",
     "js-cookie": "^3.0.5",
-    "@tanglemedia/svelte-starter-core": "0.0.16"
+    "@tanglemedia/svelte-starter-core": "0.0.17"
   },
   "peerDependencies": {
     "@sveltejs/kit": ">=2 <3",

package/src/adapter/api-adapter.ts

@@ -0,0 +1,168 @@
+import {
+  aggregate,
+  createItem,
+  deleteItem,
+  readItem,
+  readItems,
+  updateItem,
+  uploadFiles,
+  type DirectusClient,
+  type RestClient
+} from '@directus/sdk';
+import {
+  ApiAdapterAbstract,
+  type AnyObject,
+  type ApiAdapterRequestConfig,
+  type ApiId,
+  type ApiResponse,
+  type BaseApiMethods
+} from '@tanglemedia/svelte-starter-core';
+import type { DirectusConfig, SchemaShape } from '../types/adapter.types';
+
+export type AdapterClient<Schema extends SchemaShape = SchemaShape> = DirectusClient<Schema> &
+  RestClient<Schema>;
+
+export class DirectusApiAdapter<
+  Schema extends SchemaShape = SchemaShape,
+  Path extends string = keyof SchemaShape
+> extends ApiAdapterAbstract<DirectusConfig, ApiAdapterRequestConfig, Path, AdapterClient> {
+  constructor(
+    protected config: DirectusConfig,
+    private readonly directus: AdapterClient<Schema>
+  ) {
+    super(config);
+  }
+
+  getAdapterClient(): AdapterClient<Schema> | null {
+    return this.directus;
+  }
+
+  normalizeMeta(payload: AnyObject) {
+    // todo: Transform or attempt to get meta information
+    // consider pulling count based on existing filters in order to determine pagination
+    return payload;
+  }
+
+  async transformResponse<T, M extends object = AnyObject>(
+    res: T,
+    status: number = 200
+  ): Promise<ApiResponse<T, Response, M>> {
+    // const payload = (await res.json()) as T;
+
+    return {
+      body: await this.envelopeResponse<T, M>(
+        res.data || res
+        // this.normalizeMeta(payload as AnyObject) as M
+      ),
+      status: status,
+      statusText: 'OK',
+      headers: {},
+      adapterResponse: null
+    };
+  }
+
+  public getConfig(configuration?: unknown): DirectusConfig {
+    const client = this.directus;
+
+    // Add the 'configuration' property to the returned object
+    const config: DirectusConfig = {
+      ...this.config,
+      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: Path, query?: Record<string, unknown>): Promise<ApiResponse<T>> {
+    const response = await this.directus.request<T>(readItems(collection, query));
+    return this.transformResponse(response);
+  }
+
+  public async findOne<T>(
+    collection: Path,
+    key?: ApiId,
+    query?: Record<string, unknown>
+  ): Promise<ApiResponse<T>> {
+    const response = await this.directus.request<T>(readItem(collection, key, query));
+    return this.transformResponse(response);
+  }
+
+  public async aggregate<T>(
+    collection: Path,
+    query?: Record<string, unknown>
+  ): Promise<ApiResponse<T>> {
+    const response = await this.directus.request<T>(
+      aggregate(collection, {
+        aggregate: {
+          count: 'id'
+        },
+        query
+      })
+    );
+    return this.transformResponse(response);
+  }
+
+  public async patch<T>(
+    collection: Path,
+    key: ApiId,
+    query?: Record<string, unknown>
+  ): Promise<ApiResponse<T>> {
+    const response = await this.directus.request<T>(updateItem(collection, key, query));
+    return this.transformResponse(response);
+  }
+
+  public async post<T>(
+    collection: Path,
+    data: AnyObject,
+    query?: Record<string, unknown>
+  ): Promise<ApiResponse<T>> {
+    const response = await this.directus.request<T>(createItem(collection, data, query));
+    return this.transformResponse(response, 201);
+  }
+
+  public async delete<T>(collection: Path, key?: ApiId): Promise<ApiResponse<T>> {
+    const response = await this.directus.request<T>(deleteItem(collection, key));
+    return this.transformResponse(response, 202);
+  }
+
+  public async put<T>(
+    collection: Path,
+    key?: ApiId,
+    payload?: AnyObject,
+    config?: ApiAdapterRequestConfig
+  ): Promise<ApiResponse<T>> {
+    if (key) {
+      const response = await this.directus.request<T>(updateItem(collection, key, payload));
+      return this.transformResponse(response, 201);
+    } else {
+      console.error(`Error updating all ${collection}: no key specified`);
+      throw new Error('No key specified');
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  public async upload<T>(path: string = '', data: FormData): Promise<ApiResponse<T>> {
+    const response = await this.directus.request<T>(uploadFiles(data));
+    return this.transformResponse(response, 201);
+  }
+}

package/src/{auth.ts → auth.deprecated.ts}

@@ -1,70 +1,15 @@
-import type { AuthenticationClient, AuthenticationConfig, AuthenticationData } from '@directus/sdk';
-import {
-  authentication,
-  createDirectus,
-  readMe,
-  refresh,
-  rest,
-  updateMe,
-  memoryStorage
-} from '@directus/sdk';
-
+import type { AuthenticationClient, AuthenticationConfig } from '@directus/sdk';
+import { authentication, createDirectus, readMe, refresh, rest, updateMe } from '@directus/sdk';
 import type { DirectusClient, RestClient } from '@directus/sdk';
-
-import { BROWSER } from 'esm-env';
-
-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))
-//     }
-//   };
-// }
+import { AuthLocalStorage } from './storage/local-storage';
 
 const authenticationConfig: AuthenticationConfig = {
-  storage: localDirectusStorage(),
+  storage: new AuthLocalStorage(),
   autoRefresh: true,
   msRefreshBeforeExpires: 30000,
   credentials: 'include'
 };
 
-// const authenticationCookieConfig: AuthenticationConfig = {
-//   storage: cookieDirectusStorage(),
-//   autoRefresh: true,
-//   msRefreshBeforeExpires: 30000,
-//   credentials: 'include'
-// };
-
 class ApiAuthDirectus {
   private baseURL: string;
   private storageMode: 'json' | 'cookie';
@@ -78,14 +23,14 @@ class ApiAuthDirectus {
 
   private init<T extends object>(): void {
     try {
-      if(this.storageMode === 'json'){
+      if (this.storageMode === 'json') {
         this.directus = createDirectus<T>(this.baseURL)
-        .with(rest({ credentials: 'include' }))
-        .with(authentication('json', authenticationConfig));
-      }else {
+          .with(rest({ credentials: 'include' }))
+          .with(authentication('json', authenticationConfig));
+      } else {
         this.directus = createDirectus<T>(this.baseURL)
-        .with(authentication('cookie', { credentials: 'include' }))
-        .with(rest({ credentials: 'include' }));
+          .with(authentication('cookie', { credentials: 'include' }))
+          .with(rest({ credentials: 'include' }));
       }
     } catch (error) {
       console.error(`Error initializing Directus:`, error);

package/src/{static.ts → client.deprecated.ts}

@@ -1,47 +1,59 @@
+import type { AuthenticationConfig, DirectusClient, RestClient } from '@directus/sdk';
 import {
   aggregate,
+  authentication,
   createDirectus,
   createItem,
-  createUser,
   deleteItem,
   readItem,
   readItems,
   rest,
-  staticToken,
   updateItem,
-  updateItems,
   uploadFiles
 } from '@directus/sdk';
-import type { DirectusClient, RestClient, StaticTokenClient } from '@directus/sdk';
 import type {
   AnyObject,
   ApiAdapterInterface,
   ApiAdapterRequestConfig,
   BaseApiAdapterConfig
 } from '@tanglemedia/svelte-starter-core';
+import { AuthLocalStorage } from './storage/local-storage';
+
+const authenticationConfig: AuthenticationConfig = {
+  storage: new AuthLocalStorage(),
+  autoRefresh: true,
+  msRefreshBeforeExpires: 30000,
+  credentials: 'include'
+};
 
 type BaseApiMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
 
 type ApiId = string | number;
 
-class ApiStaticDirectus implements ApiAdapterInterface {
+class ApiClientDirectus implements ApiAdapterInterface {
   private baseURL: string;
-  private directusAccessToken: string;
-  private directus: DirectusClient<AnyObject> & RestClient<object> & StaticTokenClient<object>;
+  private storageMode: 'json' | 'cookie';
+  private directus: DirectusClient<object> & RestClient<object>;
 
-  constructor(baseURL: string, directusAccessToken: string) {
+  constructor(baseURL: string, storageMode: 'json' | 'cookie' = 'json') {
     this.baseURL = baseURL;
-    this.directusAccessToken = directusAccessToken;
+    this.storageMode = storageMode;
     this.init();
   }
 
   private init<T extends object>(): void {
     try {
-      this.directus = createDirectus<T>(this.baseURL)
-        .with(rest())
-        .with(staticToken(this.directusAccessToken));
+      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 admin:`, error);
+      console.error(`Error initializing Directus:`, error);
       throw error;
     }
   }
@@ -78,23 +90,10 @@ class ApiStaticDirectus implements ApiAdapterInterface {
     }
   }
 
-  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;
-    }
-  }
-
   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) {
@@ -105,7 +104,7 @@ class ApiStaticDirectus implements ApiAdapterInterface {
 
   public async findOne<T>(
     collection: string,
-    key: ApiId,
+    key?: ApiId,
     query?: Record<string, unknown>
   ): Promise<T> {
     try {
@@ -140,7 +139,7 @@ class ApiStaticDirectus implements ApiAdapterInterface {
     query?: Record<string, unknown>
   ): Promise<T> {
     try {
-      const response = await this.directus.request<T>(updateItems(collection, key, query));
+      const response = await this.directus.request<T>(updateItem(collection, key, query));
       return response;
     } catch (error) {
       console.error(`Error updating all ${collection}:`, error);
@@ -162,8 +161,7 @@ class ApiStaticDirectus implements ApiAdapterInterface {
     }
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public async delete<T>(collection: string, keys: ApiId): Promise<T> {
+  public async delete<T>(collection: string, key?: ApiId): Promise<T> {
     try {
       const response = await this.directus.request<T>(deleteItem(collection, key));
       return response;
@@ -205,4 +203,4 @@ class ApiStaticDirectus implements ApiAdapterInterface {
   }
 }
 
-export { ApiStaticDirectus };
+export { ApiClientDirectus };

package/src/index.ts

@@ -1,4 +1,12 @@
-export * from './static';
-export * from './client';
-export * from './auth';
-export * from './load-directus-api-povider';
+export * from './static.deprecated';
+export * from './client.deprecated';
+export * from './auth.deprecated';
+export * from './load-directus-api-povider.deprecated';
+
+export * from './provider/api-adapter.provider';
+export * from './provider/directus.factory';
+
+export * from './services/auth';
+export * from './services/register';
+
+export type * from './types';

package/src/{load-directus-api-povider.ts → load-directus-api-povider.deprecated.ts}

@@ -1,5 +1,6 @@
-import { ApiClientDirectus } from './client';
-import { ApiStaticDirectus } from './static';
+import { ApiClientDirectus } from './client.deprecated';
+import { ApiStaticDirectus } from './static.deprecated';
+import { ApiAuthDirectus } from './auth.deprecated';
 import {
   type ApiAdapterProviderInterface,
   type ApiAdapterInterface,
@@ -10,43 +11,49 @@ import {
 } from '@tanglemedia/svelte-starter-core';
 
 class LoadDirectusApiProvider implements ApiAdapterProviderInterface {
-  constructor(private readonly configLoader: () => Promise<Config<{ api?: ApiConfigSchema }>>, private storageMode: 'json' | 'cookie' = 'json') {}
+  constructor(
+    private readonly configLoader: () => Promise<Config<{ api?: ApiConfigSchema }>>,
+    private storageMode: 'json' | 'cookie' = 'json',
+    private key?: string | undefined
+  ) {}
 
-  async loadAdapter(
-    key?: string | undefined
-  ): Promise<ApiAdapterInterface<BaseApiAdapterConfig, ApiAdapterRequestConfig, string>> {
+  async loadAdapter(): Promise<
+    ApiAdapterInterface<BaseApiAdapterConfig, ApiAdapterRequestConfig, string>
+  > {
     const conf = await this.configLoader();
     const config = (p: string) => conf.config(p);
 
-    const apiAdapterKey = key || (config('api.default') as string);
-    const directusType = (config(`api.adapters.${apiAdapterKey}.type`) as string) || 'client';
+    const apiAdapterKey =
+      this.key === 'auth' ? 'auth' : this.key || (config('api.default') as string);
+    const directusType =
+      apiAdapterKey === 'auth'
+        ? this.key
+        : (config(`api.adapters.${apiAdapterKey}.type`) as string) || 'client';
     console.log(`api.apaters.${apiAdapterKey}.type`);
 
     if (!apiAdapterKey) {
       throw new Error(`No adapter key specified`);
     }
-    console.log(apiAdapterKey);
-    console.log(directusType);
     if (directusType) {
       if (directusType === 'client') {
         const protocol: string = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
         const host: string = config(`api.adapters.${apiAdapterKey}.host`) || '';
         return new ApiClientDirectus(`${protocol}://${host}`.trim(), this.storageMode);
+      } else if (directusType === 'auth') {
+        const protocol: string = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
+        const host: string = config(`api.adapters.${apiAdapterKey}.host`) || '';
+        return new ApiAuthDirectus(`${protocol}://${host}`.trim(), this.storageMode);
       } else {
-        console.log('static');
         const protocol: string = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
         const host: string = config(`api.adapters.${apiAdapterKey}.host`) || '';
         const accessToken: string = config(`api.adapters.${apiAdapterKey}.access_token`) || '';
         return new ApiStaticDirectus(`${protocol}://${host}`.trim(), accessToken);
       }
     } else {
-      console.log('client');
       const protocol: string = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
       const host: string = config(`api.adapters.${apiAdapterKey}.host`) || '';
       return new ApiClientDirectus(`${protocol}://${host}`.trim(), this.storageMode);
     }
-
-    console.log('This should be unreachable');
   }
 }
 

package/src/provider/api-adapter.provider.ts

@@ -0,0 +1,35 @@
+import type {
+  AdapterProviderRegister,
+  ApiAdapterInterface,
+  ApiAdapterProviderInterface
+} from '@tanglemedia/svelte-starter-core';
+import { DirectusApiAdapter } from '../adapter/api-adapter';
+import type { DirectusConfig, SchemaShape } from '../types/adapter.types';
+import { createDirectusClientFactory } from './directus.factory';
+
+export class DirectusApiProvider implements ApiAdapterProviderInterface<DirectusConfig> {
+  async loadAdapter(
+    key?: string,
+    config?: DirectusConfig
+  ): Promise<ApiAdapterInterface<DirectusConfig>> {
+    if (!config) {
+      throw new Error('Missing adapter configuration');
+    }
+
+    const client = this.createDirectusClient<SchemaShape>(config);
+
+    return new DirectusApiAdapter(config, client);
+  }
+
+  createDirectusClient<T extends object>(config: DirectusConfig) {
+    // todo: Determine if we can overwrite the fetch globals during runtime
+    return createDirectusClientFactory<T>(config);
+  }
+}
+
+export const registerDirectusProvider = (): AdapterProviderRegister => {
+  return {
+    name: 'directus',
+    provider: new DirectusApiProvider()
+  };
+};

package/src/provider/directus.factory.ts

@@ -0,0 +1,70 @@
+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) {
+    if (auth.config?.storage === 'localStorage') {
+      const authenticationConfig: AuthenticationConfig = {
+        storage: new AuthLocalStorage(),
+        autoRefresh: auth.config.autoRefresh || false,
+        msRefreshBeforeExpires: auth.config.msRefreshBeforeExpires || 0,
+        credentials: auth.config.credentials || 'include'
+      };
+      client = client.with(authentication(auth.mode, authenticationConfig));
+    } else {
+      client = client.with(authentication(auth.mode));
+    }
+  }
+
+  if (token) {
+    client = client.with(staticToken(token));
+  }
+
+  if (gql) {
+    client = client.with(graphql(gql));
+  }
+
+  return client;
+};