@data-client/rest 0.3.0 → 0.4.0

package/ts4.1/createResource.d.ts

@@ -0,0 +1,113 @@
+import { schema } from '@data-client/endpoint';
+import type { Denormalize } from '@data-client/endpoint';
+import { PathArgs, ResourcePath, ShortenPath } from './pathTypes.js';
+import { ResourceGenerics, ResourceOptions } from './resourceTypes.js';
+import { GetEndpoint, MutateEndpoint, PaginationFieldEndpoint, RestTypeNoBody } from './RestEndpoint.js';
+/** Creates collection of Endpoints for common operations on a given data/schema.
+ *
+ * @see https://resthooks.io/rest/api/createResource
+ */
+export default function createResource<O extends ResourceGenerics>({ path, schema, Endpoint, optimistic, paginationField, ...extraOptions }: Readonly<O> & ResourceOptions): Resource<O>;
+export interface Resource<O extends ResourceGenerics = {
+    path: ResourcePath;
+    schema: any;
+}> {
+    /** Get a singular item
+     *
+     * @see https://resthooks.io/rest/api/createResource#get
+     */
+    get: GetEndpoint<{
+        path: O['path'];
+        schema: O['schema'];
+    }>;
+    /** Get a list of item
+     *
+     * @see https://resthooks.io/rest/api/createResource#getlist
+     */
+    getList: 'searchParams' extends keyof O ? GetEndpoint<{
+        path: ShortenPath<O['path']>;
+        schema: schema.Collection<[
+            O['schema']
+        ]>;
+        body: 'body' extends keyof O ? O['body'] : Partial<Denormalize<O['schema']>>;
+        searchParams: O['searchParams'];
+    }> : GetEndpoint<{
+        path: ShortenPath<O['path']>;
+        schema: schema.Collection<[
+            O['schema']
+        ]>;
+        body: 'body' extends keyof O ? O['body'] : Partial<Denormalize<O['schema']>>;
+        searchParams: Record<string, number | string | boolean> | undefined;
+    }>;
+    /** Get a list of item
+     *
+     * @see https://dataclient.io/rest/api/createResource#getNextPage
+     */
+    getNextPage: 'paginationField' extends keyof O ? PaginationFieldEndpoint<'searchParams' extends keyof O ? GetEndpoint<{
+        path: ShortenPath<O['path']>;
+        schema: schema.Collection<[
+            O['schema']
+        ]>;
+        searchParams: O['searchParams'];
+    }> : GetEndpoint<{
+        path: ShortenPath<O['path']>;
+        schema: schema.Collection<[
+            O['schema']
+        ]>;
+        searchParams: Record<string, number | string | boolean> | undefined;
+    }>, Exclude<O['paginationField'], undefined>> : undefined;
+    /** Create a new item (POST)
+     *
+     * @see https://resthooks.io/rest/api/createResource#create
+     */
+    create: 'searchParams' extends keyof O ? MutateEndpoint<{
+        path: ShortenPath<O['path']>;
+        schema: schema.Collection<[
+            O['schema']
+        ]>['push'];
+        body: 'body' extends keyof O ? O['body'] : Partial<Denormalize<O['schema']>>;
+        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']>>;
+    }>;
+    /** Update an item (PUT)
+     *
+     * @see https://resthooks.io/rest/api/createResource#update
+     */
+    update: 'body' extends keyof O ? MutateEndpoint<{
+        path: O['path'];
+        body: O['body'];
+        schema: O['schema'];
+    }> : MutateEndpoint<{
+        path: O['path'];
+        body: Partial<Denormalize<O['schema']>>;
+        schema: O['schema'];
+    }>;
+    /** Update an item (PATCH)
+     *
+     * @see https://resthooks.io/rest/api/createResource#partialupdate
+     */
+    partialUpdate: 'body' extends keyof O ? MutateEndpoint<{
+        path: O['path'];
+        body: Partial<O['body']>;
+        schema: O['schema'];
+    }> : MutateEndpoint<{
+        path: O['path'];
+        body: Partial<Denormalize<O['schema']>>;
+        schema: O['schema'];
+    }>;
+    /** Delete an item (DELETE)
+     *
+     * @see https://resthooks.io/rest/api/createResource#delete
+     */
+    delete: RestTypeNoBody<PathArgs<O['path']>, O['schema'] extends schema.EntityInterface & {
+        process: any;
+    } ? schema.Invalidate<O['schema']> : O['schema'], undefined, Partial<PathArgs<O['path']>>, {
+        path: O['path'];
+    }>;
+}
+//# sourceMappingURL=createResource.d.ts.map

package/ts4.1/extractCollection.d.ts

@@ -0,0 +1,14 @@
+import { Schema, schema } from '@data-client/endpoint';
+import { ExtractObject } from './extractObject.js';
+export default function extractCollection<M extends <C extends schema.Collection>(collection: C) => any, S extends Schema | undefined>(s: S, mapper: M): ExtractCollection<S> | undefined;
+export type ExtractCollection<S extends Schema | undefined> = S extends {
+    push: any;
+    unshift: any;
+    assign: any;
+    schema: Schema;
+} ? S : S extends schema.Object<infer T> ? ExtractObject<T> : S extends Exclude<Schema, {
+    [K: string]: any;
+}> ? never : S extends {
+    [K: string]: Schema;
+} ? ExtractObject<S> : never;
+//# sourceMappingURL=extractCollection.d.ts.map

package/ts4.1/extractObject.d.ts

@@ -0,0 +1,6 @@
+import { Schema } from '@data-client/endpoint';
+import { ExtractCollection } from './extractCollection.js';
+export type ExtractObject<S extends Record<string, any>> = {
+    [K in keyof S]: S[K] extends Schema ? ExtractCollection<S[K]> : never;
+}[keyof S];
+//# sourceMappingURL=extractObject.d.ts.map

package/ts4.1/getArrayPath.d.ts

@@ -0,0 +1,3 @@
+import { Schema } from '@data-client/endpoint';
+export default function getArrayPath(s: Schema | undefined): string[] | false;
+//# sourceMappingURL=getArrayPath.d.ts.map

package/ts4.1/hookifyResource.d.ts

@@ -0,0 +1,14 @@
+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>;
+export type HookResource<R extends {}> = {
+    [K in Extract<keyof R, string> as `use${Capitalize<K>}`]: () => R[K];
+};
+//# sourceMappingURL=hookifyResource.d.ts.map

package/ts4.1/index.d.ts

@@ -0,0 +1,14 @@
+export { default as RestEndpoint } from './RestEndpoint.js';
+export type { GetEndpoint, MutateEndpoint, 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 type { ResourceOptions, ResourceGenerics } from './resourceTypes.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';
+export * from './RestEndpoint.js';
+//# sourceMappingURL=index.d.ts.map

package/ts4.1/mapCollection.d.ts

@@ -0,0 +1,16 @@
+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;
+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];
+};
+export {};
+//# sourceMappingURL=mapCollection.d.ts.map

package/ts4.1/next/index.d.ts

@@ -0,0 +1,6 @@
+export * from '../RestEndpoint.js';
+export { default as RestEndpoint } from '../RestEndpoint.js';
+export { default as createResource } from '../createResource.js';
+export type { Resource } from '../createResource.js';
+export type { ResourceOptions, ResourceGenerics } from '../resourceTypes.js';
+//# sourceMappingURL=index.d.ts.map

package/ts4.1/paginatedCollections.d.ts

@@ -0,0 +1,3 @@
+export declare function paginatedMerge(existing: any[], incoming: any[]): any[];
+export declare const paginatedFilter: <C extends (...args: readonly any[]) => readonly any[]>(removeCursor: C) => (...args: Parameters<C>) => (collectionKey: Record<string, string>) => boolean;
+//# sourceMappingURL=paginatedCollections.d.ts.map

package/ts4.1/paginationUpdate.d.ts

@@ -0,0 +1,10 @@
+import { Schema } from '@data-client/endpoint';
+export default function paginationUpdate<E extends {
+    schema: Schema;
+    key: any;
+} & ((...args: any) => Promise<any>), A extends any[]>(endpoint: E, removeCursor: (...args: A) => readonly [
+    ...Parameters<typeof endpoint>
+]): (newPage: any, ...args: A) => {
+    [x: number]: (existing: any) => any;
+};
+//# sourceMappingURL=paginationUpdate.d.ts.map

package/ts4.1/paramsToString.d.ts

@@ -0,0 +1,2 @@
+export default function paramsToString(searchParams: Readonly<Record<string, string | number | boolean>>): string;
+//# sourceMappingURL=paramsToString.d.ts.map

package/ts4.1/paramsToString.native.d.ts

@@ -0,0 +1,2 @@
+export default function paramsToString(searchParams: Readonly<Record<string, string | number>>): string;
+//# sourceMappingURL=paramsToString.native.d.ts.map

package/ts4.1/pathTypes.d.ts

@@ -0,0 +1,21 @@
+type OnlyOptional<S extends string> = S extends `${infer K}?` ? K : never;
+type OnlyRequired<S extends string> = S extends `${string}?` ? never : S;
+/** 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> : S extends `${infer A}\\?${infer B}` ? PathKeys<A> | PathKeys<B> : PathSplits<S>;
+type PathSplits<S extends string> = S extends `${string}:${infer K}${'/' | ',' | '%' | '&'}${infer R}` ? PathSplits<`:${K}`> | PathSplits<R> : S extends `${string}:${infer K}:${infer R}` ? PathSplits<`:${K}`> | PathSplits<`:${R}`> : S extends `${string}:${infer K}` ? K : never;
+/** Parameters for a given path */
+export type PathArgs<S extends string> = PathKeys<S> extends never ? unknown : KeysToArgs<PathKeys<S>>;
+export type KeysToArgs<Key extends string> = {
+    [K in Key as OnlyOptional<K>]?: string | number;
+} & (OnlyRequired<Key> extends never ? unknown : {
+    [K in Key as OnlyRequired<K>]: string | number;
+});
+export type PathArgsAndSearch<S extends string> = OnlyRequired<PathKeys<S>> extends never ? Record<string, number | string | boolean> | undefined : {
+    [K in PathKeys<S> as OnlyRequired<K>]: string | number;
+} & Record<string, number | string>;
+/** Removes the last :token */
+export type ShortenPath<S extends string> = string extends S ? string : S extends `${infer B}:${infer R}` ? TrimColon<`${B}:${ShortenPath<R>}`> : '';
+type TrimColon<S extends string> = string extends S ? string : S extends `${infer R}:` ? R : S;
+export type ResourcePath = string;
+export {};
+//# sourceMappingURL=pathTypes.d.ts.map

package/ts4.1/resourceTypes.d.ts

@@ -0,0 +1,41 @@
+import type { Schema } from '@data-client/endpoint';
+import type { ResourcePath } from './pathTypes.js';
+import RestEndpoint from './RestEndpoint.js';
+export interface ResourceGenerics {
+    /** @see https://resthooks.io/rest/api/createResource#path */
+    readonly path: ResourcePath;
+    /** @see https://resthooks.io/rest/api/createResource#schema */
+    readonly schema: Schema;
+    /** @see https://resthooks.io/rest/api/createResource#paginationfield */
+    readonly paginationField?: string;
+    /** Only used for types */
+    /** @see https://dataclient.io/rest/api/createResource#body */
+    readonly body?: any;
+    /** Only used for types */
+    /** @see https://resthooks.io/rest/api/createResource#searchParams */
+    readonly searchParams?: any;
+}
+export interface ResourceOptions {
+    /** @see https://resthooks.io/rest/api/createResource#endpoint */
+    Endpoint?: typeof RestEndpoint;
+    /** @see https://resthooks.io/rest/api/createResource#optimistic */
+    optimistic?: boolean;
+    /** @see https://resthooks.io/rest/api/createResource#urlprefix */
+    urlPrefix?: string;
+    requestInit?: RequestInit;
+    getHeaders?(headers: HeadersInit): Promise<HeadersInit> | HeadersInit;
+    getRequestInit?(body: any): Promise<RequestInit> | RequestInit;
+    fetchResponse?(input: RequestInfo, init: RequestInit): Promise<any>;
+    parseResponse?(response: Response): Promise<any>;
+    /** Default data expiry length, will fall back to NetworkManager default if not defined */
+    readonly dataExpiryLength?: number;
+    /** Default error expiry length, will fall back to NetworkManager default if not defined */
+    readonly errorExpiryLength?: number;
+    /** Poll with at least this frequency in miliseconds */
+    readonly pollFrequency?: number;
+    /** Marks cached resources as invalid if they are stale */
+    readonly invalidIfStale?: boolean;
+    /** Determines whether to throw or fallback to */
+    errorPolicy?(error: any): 'hard' | 'soft' | undefined;
+}
+//# sourceMappingURL=resourceTypes.d.ts.map

package/ts4.1/test-fixtures.d.ts

@@ -0,0 +1,141 @@
+export declare const payload: {
+    id: number;
+    title: string;
+    content: string;
+    tags: string[];
+};
+export declare const createPayload: {
+    id: number;
+    title: string;
+    content: string;
+    tags: string[];
+};
+export declare const articlesPages: {
+    prevPage: string;
+    nextPage: string;
+    results: ({
+        id: number;
+        title: string;
+        content: string;
+        tags: string[];
+    } | {
+        id: number;
+        title: string;
+        content: string;
+        tags?: undefined;
+    })[];
+};
+export declare const users: {
+    id: number;
+    username: string;
+    email: string;
+    isAdmin: boolean;
+}[];
+export declare const nested: ({
+    id: number;
+    title: string;
+    content: string;
+    tags: string[];
+    author: {
+        id: number;
+        username: string;
+        email?: undefined;
+    };
+} | {
+    id: number;
+    title: string;
+    content: string;
+    author: {
+        id: number;
+        username: string;
+        email: string;
+    };
+    tags?: undefined;
+})[];
+export declare const moreNested: ({
+    id: number;
+    title: string;
+    content: string;
+    tags: string[];
+    author: {
+        id: number;
+        username: string;
+        email?: undefined;
+    };
+} | {
+    id: number;
+    title: string;
+    content: string;
+    author: {
+        id: number;
+        username: string;
+        email: string;
+    };
+    tags?: undefined;
+})[];
+export declare const valuesFixture: {
+    first: {
+        id: number;
+        title: string;
+        content: string;
+        tags: never[];
+    };
+    second: {
+        id: number;
+        name: string;
+        content: string;
+        tags: never[];
+    };
+};
+export declare const paginatedFirstPage: {
+    nextPage: string;
+    data: {
+        results: ({
+            id: number;
+            title: string;
+            content: string;
+            tags: string[];
+            author: {
+                id: number;
+                username: string;
+                email?: undefined;
+            };
+        } | {
+            id: number;
+            title: string;
+            content: string;
+            author: {
+                id: number;
+                username: string;
+                email: string;
+            };
+            tags?: undefined;
+        })[];
+    };
+};
+export declare const paginatedSecondPage: {
+    data: {
+        results: ({
+            id: number;
+            title: string;
+            content: string;
+            tags: string[];
+            author: {
+                id: number;
+                username: string;
+                email?: undefined;
+            };
+        } | {
+            id: number;
+            title: string;
+            content: string;
+            author: {
+                id: number;
+                username: string;
+                email: string;
+            };
+            tags?: undefined;
+        })[];
+    };
+};
+//# sourceMappingURL=test-fixtures.d.ts.map

package/ts4.1/utiltypes.d.ts

@@ -0,0 +1,21 @@
+/** Extracts only the keys that will be required
+ *
+ * Removes optional, as well as unbounded (aka 'string')
+ *
+ * @example
+ ```
+RequiredKeys<{
+  opt?: string;
+  bob: string;
+  alice: number;
+  [k: string]: string | number | undefined;
+}> // = 'bob' | 'alice'
+ ```
+ */
+export type RequiredKeys<T> = Values<OnlyRequired<T>>;
+type OnlyRequired<T> = {
+    [K in keyof T as string extends K ? never : K]-?: {} extends Pick<T, K> ? never : K;
+};
+type Values<T> = T[Exclude<keyof T, number>];
+export {};
+//# sourceMappingURL=utiltypes.d.ts.map