@tanglemedia/svelte-starter-directus-api 7.0.0 → 9.0.0-next.0

package/src/adapter/api-adapter.ts

@@ -10,9 +10,7 @@ import {
   updateItems,
   uploadFiles,
   type AllCollections,
-  type DirectusClient,
-  type RegularCollections,
-  type RestClient
+  type RegularCollections
 } from '@directus/sdk';
 import {
   ApiAdapterAbstract,
@@ -24,15 +22,19 @@ import {
   type ApiDeleteManyQuery,
   type ApiFindQuery,
   type ApiId,
+  type ApiPatchQuery,
+  type ApiPostQuery,
+  type ApiPutQuery,
   type ApiResponse,
   type ApiUpdateManyQuery,
   type BaseApiMethods,
   type HandleEvent
 } from '@tanglemedia/svelte-starter-core';
-import type { DirectusConfig, SchemaShape } from '../types/adapter.types';
+import type { DirectusAdapterClient, DirectusConfig, SchemaShape } from '../types/adapter.types';
 
-export type AdapterClient<Schema extends SchemaShape = SchemaShape> = DirectusClient<Schema> &
-  RestClient<Schema>;
+type PathKey<Schema extends SchemaShape> = Extract<RegularCollections<Schema>, string>;
+
+export type AdapterClient<Schema extends SchemaShape = SchemaShape> = DirectusAdapterClient<Schema>;
 
 const allowedQueryKeys = [
   'fields',
@@ -49,17 +51,15 @@ const allowedQueryKeys = [
   'aggregate',
   'deep',
   'alias'
-];
+] as const;
+
+type Q = Record<string, unknown>;
 
-/**
- * TODO: Various types fixes. The current adapter doesn't correctly follow the types defined under the ApiAdapterAbstract.
- * See the fetch adapter under the core
- */
 export class DirectusApiAdapter<
     Schema extends SchemaShape = SchemaShape,
-    Path extends RegularCollections<Schema> = RegularCollections<Schema>
+    Path extends PathKey<Schema> = PathKey<Schema>
   >
-  extends ApiAdapterAbstract<DirectusConfig, ApiAdapterRequestConfig, Path, AdapterClient>
+  extends ApiAdapterAbstract<DirectusConfig, ApiAdapterRequestConfig, Path, AdapterClient<Schema>>
   implements ApiAdapterHandle
 {
   constructor(
@@ -70,8 +70,7 @@ export class DirectusApiAdapter<
   }
 
   async handle(event: HandleEvent) {
-    const f = event.fetch;
-    this.directus.globals.fetch = f;
+    this.directus.globals.fetch = event.fetch;
   }
 
   getAdapterClient(): AdapterClient<Schema> | null {
@@ -82,51 +81,43 @@ export class DirectusApiAdapter<
     const payload = response.data,
       meta = response.meta as Record<string, unknown>;
 
-    if (!meta) {
-      return {};
-    }
-
-    if (typeof meta.total === 'undefined') {
+    if (!meta || typeof meta.total === 'undefined') {
       return {};
     }
 
     const displayed = Array.isArray(payload) ? payload.length : 0;
-
     const total = Number(meta.total);
 
-    // todo: Transform or attempt to get meta information
-    // consider pulling count based on existing filters in order to determine pagination
     return { total, displayed };
   }
 
-  async includeTotals(collection: AllCollections<Schema>, query?: ApiFindQuery<any>) {
+  async includeTotals(collection: Path, query?: ApiFindQuery<any>) {
     if (true !== this.config.configuration.includeTotals) {
       return null;
     }
 
     const { filter, search } = query || {};
-
     // default to count. Note that there is a bug in directus where
     // the wrong counts are being returned if there are nested filters.
     // A quick fix is to set totalAggregate to countDistinct
     const k = this.config.configuration.totalAggregate || 'count';
     const f = this.config.configuration.totalField || 'id';
 
-    const data = await this.directus.request(
-      aggregate(collection, {
+    const data = await this.directus.request<Array<Record<string, unknown>>>(
+      aggregate(collection as unknown as AllCollections<Schema>, {
         aggregate: { [k]: f },
         query: {
           ...(filter ? { filter } : {}),
           ...(search ? { search } : {})
         }
-      })
+      } as never)
     );
 
     let total = 0;
 
     if (data && data.length === 1) {
       const c = data[0][k];
-      total = c && typeof c === 'object' ? Number(c[f]) : Number(c);
+      total = c && typeof c === 'object' ? Number((c as Record<string, unknown>)[f]) : Number(c);
     }
 
     return isNaN(total) ? 0 : total;
@@ -135,39 +126,27 @@ export class DirectusApiAdapter<
   async transformResponse<T, M extends object = AnyObject>(
     res: { data: T; meta?: AnyObject },
     status: number = 200
-  ): Promise<ApiResponse<T, Response, M>> {
+  ): Promise<ApiResponse<T, null, M>> {
     return {
-      body: await this.envelopeResponse<T, M>(
+      body: (await this.envelopeResponse<T, M>(
         res.data,
         (res.meta ? this.normalizeMeta(res as AnyObject) : {}) as M
-      ),
-      status: status,
+      )) as ApiResponse<T, null, M>['body'],
+      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 ?? this.config.configuration ?? {} // Use the provided configuration or an empty object if not provided
-    };
-
-    return Object.assign(client, config);
-  }
-
-  normalizeQuery(config: ApiAdapterRequestConfig = {}, merge?: Record<string, unknown>) {
-    const q = { ...(config?.params || {}) };
-    const c = { ...config } as Record<string, unknown>;
-    // legacy support, this pulls the directus specific keys from the config
-    const r = allowedQueryKeys.reduce<Record<string, unknown>>(
+  normalizeQuery(config: ApiAdapterRequestConfig = {}, merge?: Q) {
+    const q = { ...((config?.params as Q | undefined) || {}) };
+    const c = { ...config } as Q;
+    const r = allowedQueryKeys.reduce<Q>(
       (acc, k) => (typeof c[k] !== 'undefined' ? ((acc[k] = c[k]), acc) : acc),
       {}
     );
+
     return {
       ...q,
       ...r,
@@ -175,158 +154,241 @@ export class DirectusApiAdapter<
     };
   }
 
-  public async request<T>(
+  getId(data: object, config?: ApiAdapterRequestConfig): ApiId | null {
+    const d = data as Record<string, unknown>;
+    const q = config?.params as Q | undefined;
+
+    if (typeof d.id === 'string' || typeof d.id === 'number') {
+      return d.id;
+    }
+
+    if (q && (typeof q.id === 'string' || typeof q.id === 'number')) {
+      return q.id;
+    }
+
+    return null;
+  }
+
+  stripId(config?: ApiAdapterRequestConfig) {
+    const q = config?.params as Q | undefined;
+
+    if (!q || typeof q.id === 'undefined') {
+      return config;
+    }
+
+    const { id: _id, ...params } = q;
+
+    return {
+      ...config,
+      params
+    };
+  }
+
+  public async request<T, R = T>(
     method: BaseApiMethods,
-    url: string,
+    url: Path,
     query?: ApiAdapterRequestConfig
-  ): Promise<T> {
+  ): Promise<ApiResponse<R>> {
     try {
-      const response = await this.directus.request<T>(() => {
-        const params = JSON.stringify(query);
-        return {
-          path: `${url}?${params}`,
-          method: method
-        };
-      });
-      return response;
+      const { body, headers } = query || {};
+      const params = this.normalizeQuery(query);
+
+      const data = await this.directus.request<R>(
+        (() =>
+          ({
+            path: url,
+            method,
+            headers,
+            params,
+            ...(typeof body === 'undefined'
+              ? {}
+              : {
+                  body:
+                    body instanceof FormData || typeof body === 'string'
+                      ? body
+                      : JSON.stringify(body)
+                })
+          })) as never
+      );
+
+      return this.transformResponse({ data }, method === 'POST' ? 201 : method === 'DELETE' ? 202 : 200);
     } catch (error) {
       console.error(`Error request:`, error);
       throw error;
     }
   }
 
-  public async find<T, Q = T, R = T>(
+  public async find<T, F = T, R = T>(
     collection: Path,
-    query: ApiFindQuery<Q>,
+    query: ApiFindQuery<F>,
     config?: ApiAdapterRequestConfig
   ): Promise<ApiResponse<R[]>> {
-    query = this.normalizeQuery(config, query);
-    const response = (await this.directus.request<T>(readItems(collection, query))) as R[];
+    const q = this.normalizeQuery(config, query as Q);
+    const data = await this.directus.request<R[]>(
+      readItems(collection as unknown as RegularCollections<Schema>, q as never)
+    );
     const total = await this.includeTotals(collection, query);
+
     if (null === total) {
-      return this.transformResponse({ data: response });
+      return this.transformResponse({ data });
     }
-    // console.log('find meta', response, total)
 
-    return this.transformResponse({ data: response, meta: { total } });
+    return this.transformResponse({ data, meta: { total } });
   }
 
-  public async findOne<T>(
+  public async findOne<T, R = T>(
     collection: Path,
-    key?: ApiId,
+    key: ApiId,
     query?: ApiAdapterRequestConfig
-  ): Promise<ApiResponse<T>> {
+  ): Promise<ApiResponse<R>> {
     const q = this.normalizeQuery(query);
-    const data = await this.directus.request<T>(readItem(collection, key, query));
+    const data = await this.directus.request<R>(
+      readItem(collection as unknown as RegularCollections<Schema>, key, q as never)
+    );
     return this.transformResponse({ data });
   }
 
-  public async aggregate<T, Q = T, R = T>(
+  public async aggregate<T, F = T, R = T>(
     collection: Path,
-    query: ApiAggregateQuery<Q>,
+    query: ApiAggregateQuery<F>,
     config?: ApiAdapterRequestConfig
   ): Promise<ApiResponse<R>> {
-    const { aggregate: aggregate_, ...rest } = this.normalizeQuery(config, query);
-
-    const data = await this.directus.request<T>(
-      aggregate(collection, {
-        aggregate: aggregate_
-          ? aggregate_
-          : {
-              count: 'id'
-            },
+    const { aggregate: a, ...rest } = this.normalizeQuery(config, query as Q);
+
+    const data = await this.directus.request<R>(
+      aggregate(collection as unknown as AllCollections<Schema>, {
+        aggregate: a ? a : { count: 'id' },
         query: rest
-      })
+      } as never)
     );
 
     return this.transformResponse({ data });
   }
 
-  public async patch<T>(
+  public async patch<T extends object, R = T>(
     collection: Path,
     key: ApiId,
-    query?: Record<string, unknown>,
+    data: ApiPatchQuery<T>,
     config?: ApiAdapterRequestConfig
-  ): Promise<ApiResponse<T>> {
-    const data = await this.directus.request<T>(updateItem(collection, key, query));
-    return this.transformResponse({ data });
+  ): Promise<ApiResponse<R>> {
+    const q = this.normalizeQuery(config);
+    const res = await this.directus.request<R>(
+      updateItem(collection as never, key, data as never, q as never)
+    );
+    return this.transformResponse({ data: res });
   }
 
-  public async post<T>(
+  public async post<T extends object, R = T>(
     collection: Path,
-    data: AnyObject,
-    query?: Record<string, unknown>,
+    data: ApiPostQuery<T>,
     config?: ApiAdapterRequestConfig
-  ): Promise<ApiResponse<T>> {
-    const response = await this.directus.request<T>(createItem(collection, data, query));
-    return this.transformResponse({ data: response }, 201);
+  ): Promise<ApiResponse<R>> {
+    const q = this.normalizeQuery(config);
+    const res = await this.directus.request<R>(
+      createItem(collection as never, data as never, q as never)
+    );
+    return this.transformResponse({ data: res }, 201);
   }
 
-  public async delete<T>(
+  public async delete<T, R = T>(
     collection: Path,
-    key?: ApiId,
+    key: ApiId,
     config?: ApiAdapterRequestConfig
-  ): Promise<ApiResponse<T>> {
-    const data = await this.directus.request<T>(deleteItem(collection, key));
+  ): Promise<ApiResponse<R>> {
+    void config;
+    const data = await this.directus.request<R>(deleteItem(collection as never, key));
     return this.transformResponse({ data }, 202);
   }
 
   public async put<T extends object, R = T>(
     collection: Path,
-    key?: ApiId,
-    payload?: AnyObject,
-    query?: ApiAdapterRequestConfig
+    data: ApiPutQuery<T>,
+    config?: ApiAdapterRequestConfig
+  ): Promise<ApiResponse<R>>;
+  public async put<T extends object, R = T>(
+    collection: Path,
+    key: ApiId,
+    data?: AnyObject,
+    config?: ApiAdapterRequestConfig
+  ): Promise<ApiResponse<R>>;
+  public async put<T extends object, R = T>(
+    collection: Path,
+    keyOrData: ApiId | ApiPutQuery<T>,
+    dataOrConfig?: AnyObject | ApiAdapterRequestConfig,
+    config?: ApiAdapterRequestConfig
   ): Promise<ApiResponse<R>> {
-    if (key) {
-      const data = (await this.directus.request<T>(
-        updateItem(collection, key, payload, query)
-      )) as R;
-      return this.transformResponse({ data }, 201);
-    } else {
-      console.error(`Error updating all ${collection}: no key specified`);
+    const key =
+      typeof keyOrData === 'string' || typeof keyOrData === 'number'
+        ? keyOrData
+        : this.getId(keyOrData, dataOrConfig as ApiAdapterRequestConfig | undefined);
+    const data =
+      typeof keyOrData === 'string' || typeof keyOrData === 'number'
+        ? (dataOrConfig as AnyObject | undefined)
+        : keyOrData;
+    const q =
+      typeof keyOrData === 'string' || typeof keyOrData === 'number'
+        ? config
+        : (dataOrConfig as ApiAdapterRequestConfig | undefined);
+
+    if (!key) {
       throw new Error('No key specified');
     }
+
+    const res = await this.directus.request<R>(
+      updateItem(collection as never, key, data as never, this.normalizeQuery(this.stripId(q)) as never)
+    );
+
+    return this.transformResponse({ data: res }, 201);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  public async upload<T>(
-    path: string = '',
+  public async upload<T, R = T>(
+    path: Path,
     data: FormData,
-    config?: ApiAdapterRequestConfig
-  ): Promise<ApiResponse<T>> {
-    const response = await this.directus.request<T>(uploadFiles(data));
-    return this.transformResponse({ data: response }, 201);
+    config?: ApiAdapterRequestConfig & { method?: BaseApiMethods }
+  ): Promise<ApiResponse<R>> {
+    void path;
+    void config;
+    const res = await this.directus.request<R>(uploadFiles(data));
+    return this.transformResponse({ data: res }, 201);
   }
 
   async createMany<T, R = T>(
     path: Path,
     body: ApiCreateManyQuery<T>,
     config?: ApiAdapterRequestConfig
-  ) {
-    const data = await this.directus.request<T>(createItems(path, body.data, body?.query));
-    return this.transformResponse<R[]>({ data }, 200);
+  ): Promise<ApiResponse<R[]>> {
+    const q = this.normalizeQuery(config, ((body as Q).query as Q | undefined) || {});
+    const data = await this.directus.request<R[]>(
+      createItems(path as never, body.data as never, q as never)
+    );
+    return this.transformResponse({ data }, 200);
   }
 
   async updateMany<T, R = T>(
     path: Path,
     body: ApiUpdateManyQuery<T>,
     config?: ApiAdapterRequestConfig
-  ) {
+  ): Promise<ApiResponse<R[]>> {
     if (!body.ids) {
       throw Error('You must provide an array of keys to update');
     }
-    const data = await this.directus.request<T>(
-      updateItems(path, body.ids || [], body.data, body?.query)
+
+    const q = this.normalizeQuery(config, ((body as Q).query as Q | undefined) || {});
+    const ids = body.ids as string[] | number[];
+    const data = await this.directus.request<R[]>(
+      updateItems(path as never, ids, body.data as never, q as never)
     );
-    return this.transformResponse<R[]>({ data }, 200);
+    return this.transformResponse({ data }, 200);
   }
 
-  async deleteMany<R = null>(
+  async deleteMany<R>(
     path: Path,
     body: ApiDeleteManyQuery<ApiId>,
     config?: ApiAdapterRequestConfig
-  ) {
-    const data = await this.directus.request(deleteItems(path, body.ids));
-    return this.transformResponse<R>({ data } as R, 201);
+  ): Promise<ApiResponse<R[]>> {
+    void config;
+    const ids = body.ids as string[] | number[];
+    const data = await this.directus.request<R[]>(deleteItems(path as never, ids));
+    return this.transformResponse({ data }, 201);
   }
 }

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

@@ -1,17 +1,25 @@
 import type {
   AdapterProviderRegister,
+  ApiAdapterRequestConfig,
   ApiAdapterInterface,
   ApiAdapterProviderInterface
 } from '@tanglemedia/svelte-starter-core';
 import { DirectusApiAdapter } from '../adapter/api-adapter';
-import type { DirectusConfig, SchemaShape } from '../types/adapter.types';
+import type { DirectusAdapterClient, 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>> {
+  ): Promise<
+    ApiAdapterInterface<
+      DirectusConfig,
+      ApiAdapterRequestConfig,
+      string,
+      DirectusAdapterClient<SchemaShape>
+    >
+  > {
     if (!config) {
       throw new Error('Missing adapter configuration');
     }
@@ -21,7 +29,7 @@ export class DirectusApiProvider implements ApiAdapterProviderInterface<Directus
     return new DirectusApiAdapter(config, client);
   }
 
-  createDirectusClient<T extends object>(config: DirectusConfig) {
+  createDirectusClient<T extends SchemaShape>(config: DirectusConfig): DirectusAdapterClient<T> {
     // todo: Determine if we can overwrite the fetch globals during runtime
     return createDirectusClientFactory<T>(config);
   }