@data-client/rest 0.1.0

package/src/getArrayPath.ts

@@ -0,0 +1,20 @@
+import { Schema, schema } from '@data-client/endpoint';
+
+export default function getArrayPath(s: Schema | undefined): string[] | false {
+  if (typeof s !== 'object') return false;
+  if (s === undefined || s instanceof schema.Array || Array.isArray(s)) {
+    return [];
+  }
+  const o: Record<string, Schema> =
+    s instanceof schema.Object ? (s as any).schema : s;
+  for (const k in o) {
+    if (!o[k]) continue;
+    const path = getArrayPath(o[k]);
+    if (path !== false) {
+      // mutation is ok because there is only one path
+      path.unshift(k);
+      return path;
+    }
+  }
+  return false;
+}

package/src/hookifyResource.ts

@@ -0,0 +1,36 @@
+import { EndpointInterface } from '@data-client/endpoint';
+
+export interface HookableEndpointInterface extends EndpointInterface {
+  extend(...args: any): HookableEndpointInterface;
+}
+
+/** Turns a collection of Endpoints (Resource) into a collection of hooks.
+ * This is useful for Endpoints that need hooks to prepare their fetch requests.
+ *
+ * @see https://resthooks.io/rest/api/hookifyResource
+ */
+export default function hookifyResource<R extends {}>(
+  resource: R,
+  useRequestInit: () => RequestInit,
+): HookResource<R> {
+  const usingResource: Record<string, () => HookableEndpointInterface> = {};
+  Object.keys(resource).forEach(key => {
+    const endpoint = (resource as any)[key];
+    if (endpoint.extend !== undefined)
+      usingResource[`use${capitalizeFirstLetter(key)}`] = () => {
+        // this is false positive due to the dynamic nature of assignment
+        // eslint-disable-next-line react-hooks/rules-of-hooks
+        const requestInit = useRequestInit();
+        return endpoint.extend({ requestInit });
+      };
+  });
+  return usingResource as any;
+}
+
+export type HookResource<R extends {}> = {
+  [K in Extract<keyof R, string> as `use${Capitalize<K>}`]: () => R[K];
+};
+
+function capitalizeFirstLetter(s: string) {
+  return s.charAt(0).toUpperCase() + s.slice(1);
+}

package/src/index.ts

@@ -0,0 +1,42 @@
+Object.hasOwn =
+  Object.hasOwn ||
+  /* istanbul ignore next */ function hasOwn(it, key) {
+    return Object.prototype.hasOwnProperty.call(it, key);
+  };
+export { default as RestEndpoint } from './RestEndpoint.js';
+export type {
+  GetEndpoint,
+  MutateEndpoint,
+  NewGetEndpoint,
+  NewMutateEndpoint,
+  Defaults,
+  RestGenerics,
+  FetchGet,
+  FetchMutate,
+  RestFetch,
+  RestType,
+  RestInstance,
+  KeyofRestEndpoint,
+  RestEndpointConstructorOptions,
+  AddEndpoint,
+  PaginationFieldEndpoint,
+} from './RestEndpoint.js';
+export { default as createResource } from './createResource.js';
+export type { Resource } from './createResource.js';
+export { default as hookifyResource } from './hookifyResource.js';
+export type {
+  HookResource,
+  HookableEndpointInterface,
+} from './hookifyResource.js';
+export { default as NetworkError } from './NetworkError.js';
+export { default as paginationUpdate } from './paginationUpdate.js';
+export type { OptionsToFunction } from './OptionsToFunction.js';
+export type {
+  ShortenPath,
+  PathArgs,
+  PathKeys,
+  KeysToArgs,
+  PathArgsAndSearch,
+} from './pathTypes.js';
+
+export * from '@data-client/endpoint';

package/src/mapCollection.ts

@@ -0,0 +1,54 @@
+import { Schema, schema } from '@data-client/endpoint';
+
+export default function mapCollection<
+  M extends <C extends schema.Collection>(collection: C) => any,
+  S extends Schema | undefined,
+>(
+  s: S,
+  mapper: M,
+): S extends schema.Collection
+  ? ReturnType<typeof mapper<S>>
+  : S extends schema.Object<infer T>
+  ? {
+      [K in keyof T]: T[K] extends Schema
+        ? typeof mapCollection<M, T[K]>
+        : T[K];
+    }
+  : S extends { [K: string]: any }
+  ? {
+      [K in keyof S]: S[K] extends Schema
+        ? typeof mapCollection<M, S[K]>
+        : S[K];
+    }
+  : S {
+  if (typeof s !== 'object' || s === undefined) return s as any;
+  if (s instanceof schema.Collection) {
+    return mapper(s as any);
+  }
+  const objCopy: Record<string, Schema> = {
+    ...(s instanceof schema.Object ? (s as any).schema : s),
+  };
+  for (const k in objCopy) {
+    if (!objCopy[k]) continue;
+    objCopy[k] = mapCollection(objCopy[k], mapper) as any;
+  }
+  return objCopy as any;
+}
+
+type MapCollection<
+  M extends <C extends schema.Collection>(collection: C) => any,
+  S extends Schema | undefined,
+> = S extends schema.Collection
+  ? ReturnType<M>
+  : S extends schema.Object<infer T>
+  ? MapCollection<M, T>
+  : S extends { [K: string]: any }
+  ? MapObject<M, S>
+  : never;
+
+export type MapObject<
+  M extends (collection: schema.Collection) => any,
+  S extends Record<string, any>,
+> = {
+  [K in keyof S]: S[K] extends Schema ? MapCollection<M, S[K]> : S[K];
+};

package/src/next/OptionsToFunction.ts

@@ -0,0 +1,41 @@
+import type { FetchFunction, ResolveType } from '@data-client/endpoint';
+
+import {
+  PartialRestGenerics,
+  RestInstanceBase,
+  RestFetch,
+} from './RestEndpoint.js';
+import { PathArgs } from '../pathTypes.js';
+
+export type OptionsToFunction<
+  O extends PartialRestGenerics,
+  E extends RestInstanceBase & { body?: any },
+  F extends FetchFunction,
+> = 'path' extends keyof O
+  ? RestFetch<
+      'searchParams' extends keyof O
+        ? O['searchParams'] & PathArgs<Exclude<O['path'], undefined>>
+        : PathArgs<Exclude<O['path'], undefined>>,
+      'body' extends keyof O ? O['body'] : E['body'],
+      O['process'] extends {} ? ReturnType<O['process']> : ResolveType<F>
+    >
+  : 'body' extends keyof O
+  ? RestFetch<
+      'searchParams' extends keyof O
+        ? O['searchParams'] & PathArgs<Exclude<E['path'], undefined>>
+        : PathArgs<Exclude<E['path'], undefined>>,
+      O['body'],
+      O['process'] extends {} ? ReturnType<O['process']> : ResolveType<F>
+    >
+  : 'searchParams' extends keyof O
+  ? RestFetch<
+      O['searchParams'] & PathArgs<Exclude<E['path'], undefined>>,
+      E['body'],
+      O['process'] extends {} ? ReturnType<O['process']> : ResolveType<F>
+    >
+  : (
+      this: ThisParameterType<F>,
+      ...args: Parameters<F>
+    ) => Promise<
+      O['process'] extends {} ? ReturnType<O['process']> : ResolveType<F>
+    >;