@data-client/rest 0.18.1 → 0.18.2

package/src/__tests__/RestEndpoint.ts

@@ -197,10 +197,7 @@ const getNextPage3 = getArticleList3.getPage;
   // @ts-expect-error - remove body should not be any
   withBody.remove.body satisfies number;
   withBody.remove.body satisfies
-    | Partial<Body>
-    | Partial<Body>[]
-    | FormData
-    | undefined;
+    Partial<Body> | Partial<Body>[] | FormData | undefined;
   // push body requires full Body (not partial)
   () => withBody.push({ id: 'a' }, { title: 'hi', content: 'there' });
   // @ts-expect-error - push rejects partial body
@@ -221,9 +218,7 @@ const getNextPage3 = getArticleList3.getPage;
   // @ts-expect-error - assign body should not be any
   valuesEndpoint.assign.body satisfies number;
   valuesEndpoint.assign.body satisfies
-    | Record<string, Partial<PaginatedArticle>>
-    | FormData
-    | undefined;
+    Record<string, Partial<PaginatedArticle>> | FormData | undefined;
   () => valuesEndpoint.assign({ myKey: { id: 5, title: 'hi', content: 'ho' } });
 };
 
@@ -1560,6 +1555,27 @@ describe('RestEndpoint.fetch()', () => {
     expect(article).toMatchObject(payload2);
   });
 
+  it('getRequestInit() should JSON-encode objects and arrays, but pass other bodies through', async () => {
+    const endpoint = new RestEndpoint({ path: '/items', method: 'POST' });
+    const json = { 'Content-Type': 'application/json' };
+    for (const body of [{ a: 1 }, [{ a: 1 }, { a: 2 }], [], ['a', 5]]) {
+      const init = await endpoint.getRequestInit(body);
+      expect(init.body).toBe(JSON.stringify(body));
+      expect(init.headers).toEqual(json);
+    }
+    for (const body of [
+      new FormData(),
+      new URLSearchParams('a=1'),
+      new Blob(['a']),
+      new Uint8Array([1, 2]),
+      'raw',
+    ]) {
+      const init = await endpoint.getRequestInit(body);
+      expect(init.body).toBe(body);
+      expect(init.headers).toBeUndefined();
+    }
+  });
+
   it('should PUT with multipart form data', async () => {
     const payload2 = { id: 500, content: 'another' };
     let lastRequest: any;

package/src/__tests__/resource-construction.test.ts

@@ -1108,6 +1108,50 @@ describe('resource()', () => {
     expect(result.current.task3?.status).toEqual('in-progress');
   });
 
+  it('getList.push should send an array of items as JSON', async () => {
+    const BulkUserResource = resource({
+      path: 'http\\://test.com/groups/:group/users/:id',
+      schema: User,
+    });
+    let contentType: unknown;
+    mynock.post(`/groups/five/users`).reply(201, function (uri, body: any) {
+      contentType = this.req.headers['content-type'];
+      return body.map((user: any, i: number) => ({ id: 10 + i, ...user }));
+    });
+
+    const { result, waitForNextUpdate } = renderDataClient(() => {
+      return [
+        useSuspense(BulkUserResource.getList, { group: 'five' }),
+        useController(),
+      ] as const;
+    });
+    await waitForNextUpdate();
+    const controller = result.current[1];
+
+    await act(async () => {
+      const created = await controller.fetch(
+        BulkUserResource.getList.push,
+        { group: 'five' },
+        [{ username: 'a' }, { username: 'b' }],
+      );
+      // push's type resolves one item even for an array body (CollectionArrayAdder TODO)
+      expect((created as unknown as User[]).map(user => user.username)).toEqual(
+        ['a', 'b'],
+      );
+    });
+    expect(contentType).toBe('application/json');
+    expect(result.current[0].map(user => user.username)).toEqual([
+      'ntucker',
+      'a',
+      'b',
+    ]);
+    // create is getList.push, so it takes arrays too
+    () =>
+      controller.fetch(BulkUserResource.create, { group: 'five' }, [
+        { username: 'c' },
+      ]);
+  });
+
   it('getList.move should work with FormData body', async () => {
     class Task extends Entity {
       readonly id: number | undefined = undefined;
@@ -1177,6 +1221,9 @@ describe('resource()', () => {
       );
       expect(response.id).toEqual(3);
     });
+    // create takes FormData too
+    () =>
+      controller.fetch(TaskResource.create, { status: 'backlog' }, formData);
 
     // task should be removed from backlog
     expect(result.current.backlog).toHaveLength(1);

package/src/extractCollection.ts

@@ -20,6 +20,7 @@ export default function extractCollection<
   }
 }
 
+/** Searches wrappers like Query and Lazy through their `schema` (Entity classes have a `prototype`) */
 export type ExtractCollection<S extends Schema | undefined> =
   S extends (
     {
@@ -32,6 +33,8 @@ export type ExtractCollection<S extends Schema | undefined> =
   ) ?
     S
   : S extends schema.Object<infer T> ? ExtractObject<T>
+  : S extends { schema: infer Q; denormalize: any; prototype?: undefined } ?
+    ExtractObject<{ schema: Q }>
   : S extends Exclude<Schema, { [K: string]: any }> ? never
   : S extends { [K: string]: Schema } ? ExtractObject<S>
   : never;

package/src/paramsToString.native.ts

@@ -1,10 +1,6 @@
 export default function paramsToString(
   searchParams?:
-    | string
-    | URLSearchParams
-    | Record<string, string>
-    | string[][]
-    | undefined,
+    string | URLSearchParams | Record<string, string> | string[][] | undefined,
 ) {
   const params = new URLSearchParams(searchParams as any);
   try {

package/src/paramsToString.ts

@@ -1,10 +1,6 @@
 export default function paramsToString(
   searchParams?:
-    | string
-    | URLSearchParams
-    | Record<string, string>
-    | string[][]
-    | undefined,
+    string | URLSearchParams | Record<string, string> | string[][] | undefined,
 ) {
   const params = new URLSearchParams(searchParams);
   params.sort();

package/src/pathTypes.ts

@@ -1,11 +1,21 @@
-type CleanKey<S extends string> = S extends `"${infer K}"` ? K : S;
+// The non-`infer` pre-checks are matched without instantiating any types,
+// so plain keys (the common case) skip the inferring templates entirely.
+type CleanKey<S extends string> =
+  S extends `"${string}"` ?
+    S extends `"${infer K}"` ?
+      K
+    : S
+  : S;
 
-type KeyName<K extends string> = CleanKey<
-  K extends `*${infer N}}` ? N
-  : K extends `*${infer N}` ? N
-  : K extends `${infer N}}` ? N
-  : K
->;
+type KeyName<K extends string> =
+  K extends `*${string}` | `${string}}` ?
+    CleanKey<
+      K extends `*${infer N}}` ? N
+      : K extends `*${infer N}` ? N
+      : K extends `${infer N}}` ? N
+      : K
+    >
+  : CleanKey<K>;
 
 type KeyVal<K extends string> =
   K extends `*${string}` ? string[] : string | number;
@@ -28,37 +38,101 @@ export type SoftPathArgs<P extends string> =
 /** Computes the union of keys for a path string */
 export type PathKeys<S extends string> =
   string extends S ? string
-  : S extends `${infer A}\\${':' | '*' | '}'}${infer B}` ?
-    PathKeys<A> | PathKeys<B>
-  : Splits<S, ':'> | Splits<S, '*'>;
-
-type Splits<S extends string, M extends ':' | '*'> =
-  S extends `${string}${M}${infer K}${M}${infer R}` ?
-    Splits<`${M}${K}`, M> | Splits<`${M}${R}`, M>
-  : S extends (
-    `${string}${M}${infer K}${'/' | '\\' | '%' | '&' | '*' | ':' | '{' | ';' | ',' | '!' | '@'}${infer R}`
+  : // cheap (non-inferring) pre-check before the 3-way escape split
+  S extends `${string}\\${string}` ?
+    S extends `${infer A}\\${':' | '*' | '}'}${infer B}` ?
+      PathKeys<A> | PathKeys<B>
+    : ColonSplits<S> | StarSplits<S>
+  : ColonSplits<S> | StarSplits<S>;
+
+/** Characters that end a :param or *wildcard token */
+type PathDelimiter =
+  '/' | '\\' | '%' | '&' | '*' | ':' | '{' | ';' | ',' | '!' | '@';
+
+/** Token after every ':' in S */
+type ColonSplits<S extends string> =
+  S extends `${string}:${infer K}` ? PathToken<K> | ColonSplits<K> : never;
+
+/** `*`-prefixed token after every '*' in S */
+type StarSplits<S extends string> =
+  S extends `${string}*${infer K}` ? `*${PathToken<K>}` | StarSplits<K> : never;
+
+/** Prefix of K up to (excluding) its first PathDelimiter.
+ *
+ * Fast path: no delimiter at all, or the first '/' ends a delimiter-free token.
+ * The delimiter-union templates without `infer` are matched without instantiation. */
+type PathToken<K extends string> =
+  K extends `${string}${PathDelimiter}${string}` ?
+    K extends `${infer H}/${string}` ?
+      H extends `${string}${PathDelimiter}${string}` ?
+        PathTokenSlow<H>
+      : H
+    : PathTokenSlow<K>
+  : K;
+
+/** Cuts at the first occurrence of each delimiter (union); recursing on each
+ * candidate converges on the shortest, delimiter-free prefix. */
+type PathTokenSlow<K extends string> =
+  K extends `${infer H}${PathDelimiter}${string}` ? PathToken<H> : K;
+
+export type KeysToArgs<Key extends string> = OptionalArgs<Key> &
+  (RequiredPathKeys<Key> extends never ? unknown : RequiredArgs<Key>);
+
+/** Wide keys (`string`, template patterns) keep the original key-remapping
+ * form so index signatures (and their `keyof`) stay exactly the same. */
+type HasWideKey<Key extends string> =
+  true extends (
+    Key extends string ?
+      {} extends { [P in Key]: 1 } ?
+        true
+      : never
+    : never
   ) ?
-    Splits<`${M}${K}`, M> | Splits<R, M>
-  : S extends `${string}${M}${infer K}` ?
-    M extends '*' ?
-      `*${K}`
-    : K
-  : never;
-
-export type KeysToArgs<Key extends string> = {
-  [K in Key as K extends `${string}}` ? KeyName<K> : never]?: KeyVal<K>;
-} & (Exclude<Key, `${string}}`> extends never ? unknown
-: {
-    [K in Key as K extends `${string}}` ? never : KeyName<K>]: KeyVal<K>;
-  });
+    true
+  : false;
+
+// Literal keys: mapped over the computed names without an `as` clause.
+// `as` clauses get re-instantiated every time TypeScript asks whether the
+// mapped type is generic (on every relation check of hook/fetch params).
+// Each value is the KeyVal of the key(s) named N (inlined so errors show the
+// resolved type rather than an alias).
+type OptionalArgs<Key extends string> =
+  HasWideKey<Key> extends true ?
+    { [K in Key as K extends `${string}}` ? KeyName<K> : never]?: KeyVal<K> }
+  : {
+      [N in KeyName<OptionalPathKeys<Key>>]?:
+        | (N extends KeyName<Extract<OptionalPathKeys<Key>, `*${string}`>> ?
+            string[]
+          : never)
+        | (N extends KeyName<Exclude<OptionalPathKeys<Key>, `*${string}`>> ?
+            string | number
+          : never);
+    };
+
+type RequiredArgs<Key extends string> =
+  HasWideKey<Key> extends true ?
+    { [K in Key as K extends `${string}}` ? never : KeyName<K>]: KeyVal<K> }
+  : {
+      [N in KeyName<RequiredPathKeys<Key>>]:
+        | (N extends KeyName<Extract<RequiredPathKeys<Key>, `*${string}`>> ?
+            string[]
+          : never)
+        | (N extends KeyName<Exclude<RequiredPathKeys<Key>, `*${string}`>> ?
+            string | number
+          : never);
+    };
+
+type OptionalPathKeys<Key extends string> = Extract<Key, `${string}}`>;
+type RequiredPathKeys<Key extends string> = Exclude<Key, `${string}}`>;
 
 export type PathArgsAndSearch<S extends string> =
   unknown extends S ? any
   : Exclude<PathKeys<S>, `${string}}`> extends never ?
     Record<string, number | string | boolean> | undefined
   : {
-      [K in PathKeys<S> as K extends `${string}}` ? never
-      : KeyName<K>]: KeyVal<K>;
+      [
+        K in PathKeys<S> as K extends `${string}}` ? never : KeyName<K>
+      ]: KeyVal<K>;
     } & Record<string, number | string | string[]>;
 
 /** Removes the last :param or *wildcard token */

package/src/resource.ts

@@ -30,7 +30,7 @@ export default function resource<O extends ResourceGenerics>({
   optimistic,
   paginationField,
   ...extraOptions
-}: Readonly<O> & ResourceOptions): Resource<O> {
+}: Readonly<O> & O & ResourceOptions): Resource<O> {
   if (process.env.NODE_ENV !== 'production') {
     // if they lowercase and it looks like they meant to use upper-case version
     if (
@@ -78,19 +78,24 @@ This warning will not show in production.`,
     extended[key] = extended[key].extend(options);
   }
 
-  const extraMutateOptions = { ...extraOptions };
-  const extraPartialOptions = { ...extraOptions };
+  // Loosely typed: the public signature infers O from the naked `O` position,
+  // so spreading the generic rest into `new Endpoint()` would otherwise leave
+  // ContentSchemaGuard<O> as an unresolvable (deferred) conditional.
+  // Retype this if a future TypeScript resolves that conditional here.
+  const extraBaseOptions: Record<string, any> = extraOptions;
+  const extraMutateOptions = { ...extraBaseOptions };
+  const extraPartialOptions = { ...extraBaseOptions };
   const get: GetEndpoint<{ path: O['path']; schema: O['schema'] }> =
     new Endpoint({
-      ...extraOptions,
+      ...extraBaseOptions,
       path,
       schema,
       name: getName('get'),
     }) as any;
   if (optimistic) {
-    (extraMutateOptions as any).getOptimisticResponse = optimisticUpdate;
+    extraMutateOptions.getOptimisticResponse = optimisticUpdate;
     // TODO: Check that schema is a queryable, otherwise this doesn't make sense
-    (extraPartialOptions as any).getOptimisticResponse = optimisticPartial(
+    extraPartialOptions.getOptimisticResponse = optimisticPartial(
       schema as any,
     );
   }

package/src/resourceExtendable.ts

@@ -16,7 +16,7 @@ import type {
   ResourceInterface,
 } from './resourceTypes.js';
 import type {
-  PartialRestGenerics,
+  ExtendableRestGenerics,
   RestEndpointExtendOptions,
   RestExtendedEndpoint,
   RestInstanceBase,
@@ -35,7 +35,7 @@ export interface Extendable<
     },
     const ExtendKey extends Exclude<Extract<keyof R, string>, 'extend'>,
     // TODO: see RestEndpoint.extend TODO
-    ExtendOptions extends PartialRestGenerics | {},
+    ExtendOptions extends ExtendableRestGenerics | {},
   >(
     this: R,
     key: ExtendKey,
@@ -46,13 +46,14 @@ export interface Extendable<
         EndpointToFunction<R[ExtendKey]>
       > &
         ExtendOptions
-    >,
+    > &
+      ExtendOptions,
   ): ResourceExtension<R, ExtendKey, ExtendOptions>;
   extend<
     R extends { get: RestInstanceBase },
     const ExtendKey extends string,
     // TODO: see RestEndpoint.extend TODO
-    ExtendOptions extends PartialRestGenerics | {},
+    ExtendOptions extends ExtendableRestGenerics | {},
   >(
     this: R,
     key: ExtendKey,
@@ -63,17 +64,18 @@ export interface Extendable<
         EndpointToFunction<R['get']>
       > &
         ExtendOptions
-    >,
+    > &
+      ExtendOptions,
   ): R & {
     [key in ExtendKey]: RestExtendedEndpoint<ExtendOptions, R['get']>;
   };
   extend<
     R extends ResourceInterface,
-    Get extends PartialRestGenerics = {},
-    GetList extends PartialRestGenerics = {},
-    Update extends PartialRestGenerics = {},
-    PartialUpdate extends PartialRestGenerics = {},
-    Delete extends PartialRestGenerics = {},
+    Get extends ExtendableRestGenerics = {},
+    GetList extends ExtendableRestGenerics = {},
+    Update extends ExtendableRestGenerics = {},
+    PartialUpdate extends ExtendableRestGenerics = {},
+    Delete extends ExtendableRestGenerics = {},
   >(
     this: R,
     options: ResourceEndpointExtensions<
@@ -84,7 +86,9 @@ export interface Extendable<
       PartialUpdate,
       Delete
     >,
-  ): CustomResource<R, O, Get, GetList, Update, PartialUpdate, Delete>;
+  ): CustomResource<R, O, Get, GetList, Update, PartialUpdate, Delete> &
+    // keeps members like those added by extend('key', options)
+    Omit<R, keyof ResourceInterface | 'extend'>;
   extend<
     R extends ResourceInterface,
     T extends Record<string, EndpointInterface>,

package/src/resourceExtensionTypes.ts

@@ -8,6 +8,7 @@ import type { ResourcePath } from './pathTypes.js';
 import { Extendable } from './resourceExtendable.js';
 import { ResourceGenerics, ResourceInterface } from './resourceTypes.js';
 import type {
+  ExtendableRestGenerics,
   PartialRestGenerics,
   RestExtendedEndpoint,
   RestInstanceBase,
@@ -59,18 +60,19 @@ export type ExtendedResource<
 
 export interface ResourceEndpointExtensions<
   R extends ResourceInterface,
-  Get extends PartialRestGenerics = {},
-  GetList extends PartialRestGenerics = {},
-  Update extends PartialRestGenerics = {},
-  PartialUpdate extends PartialRestGenerics = {},
-  Delete extends PartialRestGenerics = {},
+  Get extends ExtendableRestGenerics = {},
+  GetList extends ExtendableRestGenerics = {},
+  Update extends ExtendableRestGenerics = {},
+  PartialUpdate extends ExtendableRestGenerics = {},
+  Delete extends ExtendableRestGenerics = {},
 > {
   readonly get?: RestEndpointOptions<
     unknown extends Get ? EndpointToFunction<R['get']>
     : OptionsToFunction<Get, R['get'], EndpointToFunction<R['get']>>,
     R['get']['schema']
   > &
-    Readonly<Get>;
+    Readonly<Get> &
+    Get;
   readonly getList?: RestEndpointOptions<
     unknown extends GetList ? EndpointToFunction<R['getList']>
     : OptionsToFunction<
@@ -80,13 +82,15 @@ export interface ResourceEndpointExtensions<
       >,
     R['getList']['schema']
   > &
-    Readonly<GetList>;
+    Readonly<GetList> &
+    GetList;
   readonly update?: RestEndpointOptions<
     unknown extends Update ? EndpointToFunction<R['update']>
     : OptionsToFunction<Update, R['update'], EndpointToFunction<R['update']>>,
     R['update']['schema']
   > &
-    Readonly<Update>;
+    Readonly<Update> &
+    Update;
   readonly partialUpdate?: RestEndpointOptions<
     unknown extends PartialUpdate ? EndpointToFunction<R['partialUpdate']>
     : OptionsToFunction<
@@ -96,11 +100,13 @@ export interface ResourceEndpointExtensions<
       >,
     R['partialUpdate']['schema']
   > &
-    Readonly<PartialUpdate>;
+    Readonly<PartialUpdate> &
+    PartialUpdate;
   readonly delete?: RestEndpointOptions<
     unknown extends Delete ? EndpointToFunction<R['delete']>
     : OptionsToFunction<Delete, R['delete'], EndpointToFunction<R['delete']>>,
     R['delete']['schema']
   > &
-    Readonly<Delete>;
+    Readonly<Delete> &
+    Delete;
 }

package/src/resourceTypes.ts

@@ -121,15 +121,13 @@ export interface Resource<
     MutateEndpoint<{
       path: ShortenPath<O['path']>;
       schema: schema.Collection<[O['schema']]>['push'];
-      body: 'body' extends keyof O ? O['body']
-      : Partial<Denormalize<O['schema']>>;
+      body: CreateBody<O> | CreateBody<O>[] | FormData;
       searchParams: O['searchParams'];
     }>
   : MutateEndpoint<{
       path: ShortenPath<O['path']>;
       schema: schema.Collection<[O['schema']]>['push'];
-      body: 'body' extends keyof O ? O['body']
-      : Partial<Denormalize<O['schema']>>;
+      body: CreateBody<O> | CreateBody<O>[] | FormData;
     }>;
   /** Update an item (PUT)
    *
@@ -185,3 +183,7 @@ export interface ResourceInterface {
   partialUpdate: RestInstanceBase;
   delete: RestInstanceBase;
 }
+
+/** Matches getList.push's body, since create is getList.push at runtime */
+type CreateBody<O extends { body?: any; schema: Schema }> =
+  'body' extends keyof O ? O['body'] : Partial<Denormalize<O['schema']>>;