@tanglemedia/svelte-starter-directus-api 0.0.1

package/README.md

@@ -0,0 +1,3 @@
+# Directus-api
+
+_This package is experimental and is meant for internal use only._

package/dist/auth.d.ts

@@ -0,0 +1,15 @@
+import type { DirectusClient, RestClient } from '@directus/sdk';
+declare class ApiAuthDirectus {
+    private baseURL;
+    private directus;
+    constructor(baseURL: string);
+    private init;
+    getConfig<T extends object>(): DirectusClient<T> & RestClient<object>;
+    refresh<T>(): Promise<T>;
+    getToken<T>(): Promise<T>;
+    login<T>(email: string, password: string): Promise<T>;
+    logout<T>(): Promise<T>;
+    getCurrentUser<T>(fields?: string[] | null): Promise<T>;
+    updateCurrentUser<T>(data: object): Promise<T>;
+}
+export { ApiAuthDirectus };

package/dist/auth.js

@@ -0,0 +1,117 @@
+import { createDirectus, rest, authentication, refresh, readMe, updateMe } from '@directus/sdk';
+import { browser } from '$app/environment';
+const localDirectusStorage = (storageKey = 'access_token_directus') => {
+    if (!browser || !window.localStorage) {
+        console.warn('Defaulting to memory storage');
+        return {
+            get: async () => null,
+            set: async (value) => { }
+        };
+    }
+    const storage = window.localStorage;
+    return {
+        get: async () => {
+            const data = storage.getItem(storageKey);
+            return data ? JSON.parse(data) : null;
+        },
+        set: async (value) => {
+            if (value === null) {
+                storage.removeItem(storageKey);
+            }
+            else {
+                storage.setItem(storageKey, JSON.stringify(value));
+            }
+        }
+    };
+};
+const authenticationConfig = {
+    storage: localDirectusStorage(),
+    autoRefresh: true,
+    msRefreshBeforeExpires: 30000,
+    credentials: 'include'
+};
+class ApiAuthDirectus {
+    baseURL;
+    directus;
+    constructor(baseURL) {
+        this.baseURL = baseURL;
+        this.init();
+    }
+    init() {
+        try {
+            this.directus = createDirectus(this.baseURL).with(rest({ credentials: 'include' })).with(authentication('json', authenticationConfig));
+        }
+        catch (error) {
+            console.error(`Error initializing Directus:`, error);
+            throw error;
+        }
+    }
+    getConfig() {
+        return this.directus;
+    }
+    async refresh() {
+        try {
+            const response = await this.directus.request(refresh());
+            return response;
+        }
+        catch (error) {
+            console.error(`Error refreshing :`, error);
+            throw error;
+        }
+    }
+    async getToken() {
+        try {
+            const response = await this.directus.getToken();
+            return response;
+        }
+        catch (error) {
+            console.error(`Error refreshing :`, error);
+            throw error;
+        }
+    }
+    async login(email, password) {
+        try {
+            const response = await this.directus.login(email, password);
+            return response;
+        }
+        catch (error) {
+            console.error(`Error login :`, error);
+            throw error;
+        }
+    }
+    async logout() {
+        try {
+            const response = await this.directus.logout();
+            return response;
+        }
+        catch (error) {
+            console.error(`Error refreshing :`, error);
+            throw error;
+        }
+    }
+    async getCurrentUser(fields = null) {
+        try {
+            if (!this.getToken())
+                await this.refresh();
+            const response = await this.directus.request(readMe({ fields: fields ? fields : ['*', 'roles.*'] }));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error refreshing :`, error);
+            throw error;
+        }
+    }
+    async updateCurrentUser(data) {
+        try {
+            if (!this.getToken())
+                await this.refresh();
+            const response = await this.directus.request(updateMe(data));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error refreshing :`, error);
+            throw error;
+        }
+    }
+}
+export { ApiAuthDirectus };

package/dist/client.d.ts

@@ -0,0 +1,20 @@
+import type { ApiAdapterInterface, ApiAdapterRequestConfig, AnyObject, BaseApiAdapterConfig } from '@tanglemedia/svelte-starter-core';
+type BaseApiMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+type ApiId = string | number;
+declare class ApiClientDirectus implements ApiAdapterInterface {
+    private baseURL;
+    private directus;
+    constructor(baseURL: string);
+    private init;
+    getConfig<T extends object>(configuration?: unknown): BaseApiAdapterConfig;
+    request<T>(method: BaseApiMethods, url: string, queryParams?: Record<string, any>): Promise<T>;
+    find<T>(collection: string, queryParams?: Record<string, unknown>): Promise<T>;
+    findOne<T>(collection: string, key?: ApiId, queryParams?: Record<string, unknown>): Promise<T>;
+    aggregate<T>(collection: string, queryParams?: Record<string, unknown>): Promise<T>;
+    patch<T>(collection: string, key: ApiId, queryParams?: Record<string, unknown>): Promise<T>;
+    post<T>(collection: string, data: AnyObject, queryParams?: Record<string, unknown>): Promise<T>;
+    delete<T>(collection: string, key?: 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 { ApiClientDirectus };

package/dist/client.js

@@ -0,0 +1,161 @@
+import { createDirectus, rest, authentication, readItems, readItem, updateItem, updateItems, createItem, createItems, deleteItem, deleteItems, aggregate, uploadFiles } from '@directus/sdk';
+import { browser } from '$app/environment';
+const localDirectusStorage = (storageKey = 'access_token_directus') => {
+    if (!browser || !window.localStorage) {
+        console.warn('Defaulting to memory storage');
+        return {
+            get: async () => null,
+            set: async (value) => { }
+        };
+    }
+    const storage = window.localStorage;
+    return {
+        get: async () => {
+            const data = storage.getItem(storageKey);
+            return data ? JSON.parse(data) : null;
+        },
+        set: async (value) => { }
+    };
+};
+const authenticationConfig = {
+    storage: localDirectusStorage(),
+    autoRefresh: true,
+    msRefreshBeforeExpires: 30000,
+    credentials: 'include'
+};
+class ApiClientDirectus {
+    baseURL;
+    directus;
+    constructor(baseURL) {
+        this.baseURL = baseURL;
+        this.init();
+    }
+    init() {
+        try {
+            this.directus = createDirectus(this.baseURL).with(rest({ credentials: 'include' })).with(authentication('json', authenticationConfig));
+        }
+        catch (error) {
+            console.error(`Error initializing Directus:`, 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, queryParams) {
+        try {
+            const response = await this.directus.request(() => {
+                const params = JSON.stringify(queryParams);
+                return {
+                    path: `${url}?${params}`,
+                    method: method
+                };
+            });
+            return response;
+        }
+        catch (error) {
+            console.error(`Error request:`, error);
+            throw error;
+        }
+    }
+    async find(collection, queryParams) {
+        console.log('in find');
+        try {
+            // console.log(`Find ${collection}`)
+            const response = await this.directus.request(readItems(collection, queryParams));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error fetching all ${collection}:`, error);
+            throw error;
+        }
+    }
+    async findOne(collection, key, queryParams) {
+        try {
+            const response = await this.directus.request(readItem(collection, key, queryParams));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error fetching ${collection}:`, error);
+            throw error;
+        }
+    }
+    async aggregate(collection, queryParams) {
+        try {
+            const response = await this.directus.request(aggregate(collection, {
+                aggregate: {
+                    count: 'id'
+                },
+                queryParams
+            }));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error fetching total of ${collection}:`, error);
+            throw error;
+        }
+    }
+    async patch(collection, key, queryParams) {
+        try {
+            const response = await this.directus.request(updateItem(collection, key, queryParams));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error updating all ${collection}:`, error);
+            throw error;
+        }
+    }
+    async post(collection, data, queryParams) {
+        try {
+            const response = await this.directus.request(createItem(collection, data, queryParams));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error creating items ${collection}:`, error);
+            throw error;
+        }
+    }
+    async delete(collection, key) {
+        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;
+        }
+    }
+    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 { ApiClientDirectus };

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from './static';
+export * from './client';
+export * from './auth';
+export * from './load-directus-api-povider';

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from './static';
+export * from './client';
+export * from './auth';
+export * from './load-directus-api-povider';

package/dist/load-directus-api-povider.d.ts

@@ -0,0 +1,9 @@
+import { type ApiAdapterProviderInterface, type ApiAdapterInterface, type ApiAdapterRequestConfig, type BaseApiAdapterConfig, type Config, type ApiConfigSchema } from '@tanglemedia/svelte-starter-core';
+declare class LoadDirectusApiProvider implements ApiAdapterProviderInterface {
+    private readonly configLoader;
+    constructor(configLoader: () => Promise<Config<{
+        api?: ApiConfigSchema;
+    }>>);
+    loadAdapter(key?: string | undefined): Promise<ApiAdapterInterface<BaseApiAdapterConfig, ApiAdapterRequestConfig, string>>;
+}
+export { LoadDirectusApiProvider };

package/dist/load-directus-api-povider.js

@@ -0,0 +1,43 @@
+import { ApiClientDirectus } from './client';
+import { ApiStaticDirectus } from './static';
+import {} from '@tanglemedia/svelte-starter-core';
+class LoadDirectusApiProvider {
+    configLoader;
+    constructor(configLoader) {
+        this.configLoader = configLoader;
+    }
+    async loadAdapter(key) {
+        const conf = await this.configLoader();
+        const config = (p) => conf.config(p);
+        const apiAdapterKey = key || config('api.default');
+        const directusType = config(`api.adapters.${apiAdapterKey}.type`) || '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 = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
+                const host = config(`api.adapters.${apiAdapterKey}.host`) || '';
+                return new ApiClientDirectus(`${protocol}://${host}`.trim());
+            }
+            else {
+                console.log('static');
+                const protocol = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
+                const host = config(`api.adapters.${apiAdapterKey}.host`) || '';
+                const accessToken = config(`api.adapters.${apiAdapterKey}.access_token`) || '';
+                return new ApiStaticDirectus(`${protocol}://${host}`.trim(), accessToken);
+            }
+        }
+        else {
+            console.log('client');
+            const protocol = config(`api.adapters.${apiAdapterKey}.protocol`) || '';
+            const host = config(`api.adapters.${apiAdapterKey}.host`) || '';
+            return new ApiClientDirectus(`${protocol}://${host}`.trim());
+        }
+        console.log('This should be unreachable');
+    }
+}
+export { LoadDirectusApiProvider };

package/dist/static.d.ts

@@ -0,0 +1,31 @@
+import type { ApiAdapterInterface, ApiAdapterRequestConfig, AnyObject, 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, queryParams?: Record<string, any>): 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, queryParams?: Record<string, any>): Promise<T>;
+    findOne<T>(collection: string, key: ApiId, queryParams?: Record<string, any>): Promise<T>;
+    aggregate<T>(collection: string, queryParams?: Record<string, any>): Promise<T>;
+    patch<T>(collection: string, key: ApiId, queryParams?: Record<string, any>): Promise<T>;
+    post<T>(collection: string, data: AnyObject, queryParams?: Record<string, any>): 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

@@ -0,0 +1,149 @@
+import { createDirectus, rest, staticToken, readItems, readItem, updateItem, updateItems, createItem, createUser, deleteItem, aggregate, 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, queryParams) {
+        try {
+            const response = await this.directus.request(() => {
+                const params = JSON.stringify(queryParams);
+                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, queryParams) {
+        try {
+            const response = await this.directus.request(readItems(collection, queryParams));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error fetching all ${collection}:`, error);
+            throw error;
+        }
+    }
+    async findOne(collection, key, queryParams) {
+        try {
+            const response = await this.directus.request(readItem(collection, key, queryParams));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error fetching ${collection}:`, error);
+            throw error;
+        }
+    }
+    async aggregate(collection, queryParams) {
+        try {
+            const response = await this.directus.request(aggregate(collection, {
+                aggregate: {
+                    count: 'id'
+                },
+                queryParams
+            }));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error fetching total of ${collection}:`, error);
+            throw error;
+        }
+    }
+    async patch(collection, key, queryParams) {
+        try {
+            const response = await this.directus.request(updateItems(collection, key, queryParams));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error updating all ${collection}:`, error);
+            throw error;
+        }
+    }
+    async post(collection, data, queryParams) {
+        try {
+            const response = await this.directus.request(createItem(collection, data, queryParams));
+            return response;
+        }
+        catch (error) {
+            console.error(`Error creating items ${collection}:`, error);
+            throw error;
+        }
+    }
+    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;
+        }
+    }
+    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/package.json

@@ -0,0 +1,65 @@
+{
+  "name": "@tanglemedia/svelte-starter-directus-api",
+  "version": "0.0.1",
+  "main": "src/index.ts",
+  "types": "src/index.ts",
+  "description": "directus API wrapper for all the directus sdk functionality",
+  "type": "module",
+  "module": "src/index.ts",
+  "svelte": "src/index.ts",
+  "license": "MIT",
+  "files": [
+    "dist",
+    "src",
+    "!tests"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "svelte": "./dist/index.js",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "devDependencies": {
+    "@sveltejs/adapter-auto": "^2.1.1",
+    "@sveltejs/package": "^2.2.2",
+    "@testing-library/jest-dom": "^6.1.4",
+    "@testing-library/svelte": "^4.0.5",
+    "@vitest/coverage-v8": "^0.34.6",
+    "jsdom": "^22.1.0",
+    "msw": "^2.0.8",
+    "svelte": "^4.2.7",
+    "svelte-check": "^3.6.0",
+    "vite": "^4.5.0",
+    "vitest": "^0.34.6",
+    "eslint-config-custom": "0.0.0"
+  },
+  "dependencies": {
+    "@directus/sdk": "^13.0.2",
+    "@tanglemedia/svelte-starter-core": "^0.0.5",
+    "flowbite-svelte": "^0.44.19",
+    "fontawesome-svelte": "^2.0.1",
+    "svelte-fa": "^3.0.4",
+    "tailwind-merge": "^2.0.0"
+  },
+  "peerDependencies": {
+    "@sveltejs/kit": ">=1.20 <2",
+    "svelte": ">=4 <5"
+  },
+  "babelMacros": {
+    "fontawesome-svg-core": {
+      "license": "free"
+    }
+  },
+  "scripts": {
+    "build": "svelte-package --input ./src --output ./dist",
+    "dev": "npm run build -- --watch",
+    "lint": "prettier --check --ignore-path=../../.prettierignore . && eslint \".\" --ignore-path=../../.prettierignore",
+    "format": "prettier --write --ignore-path=../../.prettierignore . && eslint \".\" --ignore-path=../../.prettierignore",
+    "check": "svelte-kit sync && svelte-check --tsconfig ./tsconfig.json",
+    "test": "vitest",
+    "test:debug": "vitest --test-timeout=0 --reporter=verbose --coverage",
+    "clean": "rimraf ./dist && rimraf ./coverage"
+  }
+}

package/src/auth.ts

@@ -0,0 +1,133 @@
+import {
+  createDirectus,
+  rest,
+  authentication,
+  refresh,
+  readMe,
+  updateMe
+} from '@directus/sdk';
+import type { AuthenticationData, AuthenticationConfig } from '@directus/sdk';
+
+import type { DirectusClient, RestClient } from '@directus/sdk';
+
+import { browser } from '$app/environment';
+
+const localDirectusStorage = (storageKey: string = 'access_token_directus') => {
+  if (!browser || !window.localStorage) {
+    console.warn('Defaulting to memory storage');
+    return {
+      get: async (): Promise<AuthenticationData | null> => null,
+      set: async (value: AuthenticationData | null): Promise<void> => {}
+    };
+  }
+
+  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 authenticationConfig: AuthenticationConfig = {
+  storage: localDirectusStorage(),
+  autoRefresh: true,
+  msRefreshBeforeExpires: 30000,
+  credentials: 'include'
+};
+
+class ApiAuthDirectus {
+  private baseURL: string;
+  private directus: DirectusClient<object> & RestClient<object>;
+
+  constructor(baseURL: string) {
+    this.baseURL = baseURL;
+    this.init();
+  }
+
+  private init<T extends object>(): void {
+    try {
+      this.directus = createDirectus<T>(this.baseURL).with(rest({credentials: 'include'})).with(authentication('json', authenticationConfig))
+    } catch (error) {
+      console.error(`Error initializing Directus:`, error);
+      throw error;
+    }
+  }
+
+  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 this.directus.request<T>(refresh());
+      return response;
+    } catch (error) {
+      console.error(`Error refreshing :`, error);
+      throw error;
+    }
+  }
+
+  public async getToken<T>(): Promise<T> {
+    try {
+      const response = await this.directus.getToken();
+      return response;
+    } catch (error) {
+      console.error(`Error refreshing :`, error);
+      throw error;
+    }
+  }
+
+  public async login<T>(email: string, password: string): Promise<T> {
+    try {
+      const response = await this.directus.login(email, password);
+      return response;
+    } catch (error) {
+      console.error(`Error login :`, error);
+      throw error;
+    }
+  }
+
+  public async logout<T>(): Promise<T> {
+    try {
+      const response = await this.directus.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 this.directus.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 this.directus.request<T>(updateMe(data));
+      return response;
+    } catch (error) {
+      console.error(`Error refreshing :`, error);
+      throw error;
+    }
+  }
+}
+
+export { ApiAuthDirectus };

package/src/client.ts

@@ -0,0 +1,196 @@
+import {
+  createDirectus,
+  rest,
+  authentication,
+  readItems,
+  readItem,
+  updateItem,
+  updateItems,
+  createItem,
+  createItems,
+  deleteItem,
+  deleteItems,
+  aggregate,
+  uploadFiles
+} from '@directus/sdk';
+import type { AuthenticationData, AuthenticationConfig } from '@directus/sdk';
+
+import type { DirectusClient, RestClient } from '@directus/sdk';
+
+import type { ApiAdapterInterface, ApiAdapterRequestConfig, AnyObject, BaseApiAdapterConfig } from '@tanglemedia/svelte-starter-core';
+
+import { browser } from '$app/environment';
+
+const localDirectusStorage = (storageKey: string = 'access_token_directus') => {
+  if (!browser || !window.localStorage) {
+    console.warn('Defaulting to memory storage');
+    return {
+      get: async (): Promise<AuthenticationData | null> => null,
+      set: async (value: AuthenticationData | null): Promise<void> => {}
+    };
+  }
+
+  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> => {}
+  };
+};
+
+const authenticationConfig: AuthenticationConfig = {
+  storage: localDirectusStorage(),
+  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 directus: DirectusClient<object> & RestClient<object>;
+
+  constructor(baseURL: string) {
+    this.baseURL = baseURL;
+    this.init();
+  }
+
+  private init<T extends object>(): void {
+    try {
+      this.directus = createDirectus<T>(this.baseURL).with(rest({credentials: 'include'})).with(authentication('json', authenticationConfig))
+    } 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, queryParams?: Record<string, any>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(() => {
+        const params = JSON.stringify(queryParams);
+        return {
+          path: `${url}?${params}`,
+          method: method
+        };
+      });
+      return response;
+    } catch (error) {
+      console.error(`Error request:`, error);
+      throw error;
+    }
+  }
+
+  public async find<T>(collection: string, queryParams?: Record<string, unknown>): Promise<T> {
+    console.log('in find')
+    try {
+      // console.log(`Find ${collection}`)
+      const response = await this.directus.request<T>(readItems(collection, queryParams));
+      return response;
+    } catch (error) {
+      console.error(`Error fetching all ${collection}:`, error);
+      throw error;
+    }
+  }
+
+  public async findOne<T>(collection: string, key?: ApiId, queryParams?: Record<string, unknown>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(readItem(collection, key, queryParams));
+      return response;
+    } catch (error) {
+      console.error(`Error fetching ${collection}:`, error);
+      throw error;
+    }
+  }
+
+  public async aggregate<T>(collection: string, queryParams?: Record<string, unknown>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(aggregate(collection, {
+        aggregate: {
+          count: 'id'
+        },
+        queryParams
+      }));
+      return response;
+    } catch (error) {
+      console.error(`Error fetching total of ${collection}:`, error);
+      throw error;
+    }
+  }
+
+  public async patch<T>(collection: string, key: ApiId, queryParams?: Record<string, unknown>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(updateItem(collection, key, queryParams));
+      return response;
+    } catch (error) {
+      console.error(`Error updating all ${collection}:`, error);
+      throw error;
+    }
+  }
+
+  public async post<T>(collection: string, data: AnyObject, queryParams?: Record<string, unknown>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(createItem(collection, data, queryParams));
+      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;
+    }
+  }
+  
+
+  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 };

package/src/index.ts

@@ -0,0 +1,4 @@
+export * from './static';
+export * from './client';
+export * from './auth';
+export * from './load-directus-api-povider';

package/src/load-directus-api-povider.ts

@@ -0,0 +1,47 @@
+import { ApiClientDirectus } from './client';
+import { ApiStaticDirectus } from './static';
+import { type ApiAdapterProviderInterface, type ApiAdapterInterface, type ApiAdapterRequestConfig, type BaseApiAdapterConfig, type Config, type ApiConfigSchema } from '@tanglemedia/svelte-starter-core';
+
+class LoadDirectusApiProvider implements ApiAdapterProviderInterface {
+
+  constructor(
+    private readonly configLoader: () => Promise<Config<{ api?: ApiConfigSchema }>>,
+  ) { }
+
+  async loadAdapter(key?: string | undefined): 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';
+    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());
+      } 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());
+    }
+
+    console.log('This should be unreachable')
+  }
+}
+
+export { LoadDirectusApiProvider }

package/src/static.ts

@@ -0,0 +1,176 @@
+import {
+  createDirectus,
+  rest,
+  staticToken,
+  readItems,
+  readItem,
+  updateItem,
+  updateItems,
+  createItem,
+  createUser,
+  deleteItem,
+  aggregate,
+  uploadFiles
+} from '@directus/sdk';
+
+import type { DirectusClient, RestClient, StaticTokenClient } from '@directus/sdk';
+
+import type { ApiAdapterInterface, ApiAdapterRequestConfig, AnyObject, BaseApiAdapterConfig } from '@tanglemedia/svelte-starter-core';
+
+type BaseApiMethods = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+type ApiId = string | number;
+
+class ApiStaticDirectus implements ApiAdapterInterface {
+  private baseURL: string;
+  private directusAccessToken: string;
+  private directus: DirectusClient<any> & 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, queryParams?: Record<string, any>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(() => {
+        const params = JSON.stringify(queryParams);
+        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;
+    }
+  }
+
+  public async find<T>(collection: string, queryParams?: Record<string, any>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(readItems(collection, queryParams));
+      return response;
+    } catch (error) {
+      console.error(`Error fetching all ${collection}:`, error);
+      throw error;
+    }
+  }
+
+  public async findOne<T>(collection: string, key: ApiId, queryParams?: Record<string, any>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(readItem(collection, key, queryParams));
+      return response;
+    } catch (error) {
+      console.error(`Error fetching ${collection}:`, error);
+      throw error;
+    }
+  }
+
+  public async aggregate<T>(collection: string, queryParams?: Record<string, any>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(aggregate(collection, {
+        aggregate: {
+          count: 'id'
+        },
+        queryParams
+      }));
+      return response;
+    } catch (error) {
+      console.error(`Error fetching total of ${collection}:`, error);
+      throw error;
+    }
+  }
+
+  public async patch<T>(collection: string, key: ApiId, queryParams?: Record<string, any>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(updateItems(collection, key, queryParams));
+      return response;
+    } catch (error) {
+      console.error(`Error updating all ${collection}:`, error);
+      throw error;
+    }
+  }
+
+  public async post<T>(collection: string, data: AnyObject, queryParams?: Record<string, any>): Promise<T> {
+    try {
+      const response = await this.directus.request<T>(createItem(collection, data, queryParams));
+      return response;
+    } catch (error) {
+      console.error(`Error creating items ${collection}:`, error);
+      throw error;
+    }
+  }
+
+  public async delete<T>(collection: string, keys: 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;
+    }
+  }
+
+  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 { ApiStaticDirectus };