@raphiniert/ra-data-postgrest 1.2.1 → 2.0.0-alpha.1

package/src/index.ts

@@ -1,5 +1,338 @@
-import dataProvider from './dataProvider';
-import authProvider from './authProvider';
+import {
+    fetchUtils,
+    DataProvider,
+    GetListParams,
+    GetOneParams,
+    GetManyParams,
+    GetManyReferenceParams,
+    UpdateParams,
+    UpdateManyParams,
+    CreateParams,
+    DeleteParams,
+    DeleteManyParams,
+} from 'ra-core';
+import {
+    PrimaryKey,
+    PostgRestOperator,
+    getPrimaryKey,
+    parseFilters,
+    getOrderBy,
+    dataWithId,
+    getQuery,
+    getKeyData,
+    encodeId,
+    decodeId,
+    isCompoundKey,
+} from './urlBuilder';
+import qs from 'qs';
 
-export { authProvider };
-export default dataProvider;
+/**
+ * Maps react-admin queries to a postgrest REST API
+ *
+ * This REST dialect uses postgrest syntax
+ *
+ * @see https://postgrest.org/en/stable/api.html#embedded-filters
+ *
+ * @example
+ *
+ * getList          => GET    http://my.api.url/posts?order=title.asc&offset=0&limit=24&filterField=eq.value
+ * getOne           => GET    http://my.api.url/posts?id=eq.123
+ * getMany          => GET    http://my.api.url/posts?id=in.(123,456,789)
+ * getManyReference => GET    http://my.api.url/posts?author_id=eq.345
+ * create           => POST   http://my.api.url/posts
+ * update           => PATCH  http://my.api.url/posts?id=eq.123
+ * updateMany       => PATCH  http://my.api.url/posts?id=in.(123,456,789)
+ * delete           => DELETE http://my.api.url/posts?id=eq.123
+ * deleteMany       => DELETE http://my.api.url/posts?id=in.(123,456,789)
+ *
+ * @example
+ *
+ * import * as React from 'react';
+ * import { Admin, Resource } from 'react-admin';
+ * import postgrestRestProvider from '@raphiniert/ra-data-postgrest';
+ *
+ * import { PostList } from './posts';
+ *
+ * const App = () => (
+ *     <Admin dataProvider={postgrestRestProvider('http://path.to.my.api/')}>
+ *         <Resource name="posts" list={PostList} />
+ *     </Admin>
+ * );
+ *
+ * export default App;
+ */
+
+const defaultPrimaryKeys = new Map<string, PrimaryKey>();
+
+export default (
+    apiUrl: string,
+    httpClient = fetchUtils.fetchJson,
+    defaultListOp: PostgRestOperator = 'eq',
+    primaryKeys: Map<string, PrimaryKey> = defaultPrimaryKeys
+): DataProvider => ({
+    getList: (resource, params: Partial<GetListParams> = {}) => {
+        const primaryKey = getPrimaryKey(resource, primaryKeys);
+
+        const { page, perPage } = params.pagination;
+        const { field, order } = params.sort || {};
+        const { filter, select } = parseFilters(params, defaultListOp);
+
+        let query = {
+            offset: String((page - 1) * perPage),
+            limit: String(perPage),
+            // append filters
+            ...filter,
+        };
+
+        if (field) {
+            query.order = getOrderBy(field, order, primaryKey);
+        }
+
+        if (select) {
+            query.select = select;
+        }
+
+        // add header that Content-Range is in returned header
+        const options = {
+            headers: new Headers({
+                Accept: 'application/json',
+                Prefer: 'count=exact',
+                ...(params.meta?.headers || {}),
+            }),
+        };
+
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+
+        return httpClient(url, options).then(({ headers, json }) => {
+            if (!headers.has('content-range')) {
+                throw new Error(
+                    `The Content-Range header is missing in the HTTP Response. The postgREST data provider expects 
+          responses for lists of resources to contain this header with the total number of results to build 
+          the pagination. If you are using CORS, did you declare Content-Range in the Access-Control-Expose-Headers header?`
+                );
+            }
+            return {
+                data: json.map(obj => dataWithId(obj, primaryKey)),
+                total: parseInt(
+                    headers.get('content-range').split('/').pop(),
+                    10
+                ),
+            };
+        });
+    },
+
+    getOne: (resource, params: Partial<GetOneParams> = {}) => {
+        const { id, meta } = params;
+        const primaryKey = getPrimaryKey(resource, primaryKeys);
+
+        const query = getQuery(primaryKey, id, resource, meta);
+
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+
+        return httpClient(url, {
+            headers: new Headers({
+                accept: 'application/vnd.pgrst.object+json',
+                ...(params.meta?.headers || {}),
+            }),
+        }).then(({ json }) => ({
+            data: dataWithId(json, primaryKey),
+        }));
+    },
+
+    getMany: (resource, params: Partial<GetManyParams> = {}) => {
+        const ids = params.ids;
+        const primaryKey = getPrimaryKey(resource, primaryKeys);
+
+        const query = getQuery(primaryKey, ids, resource, params.meta);
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+
+        return httpClient(url).then(({ json }) => ({
+            data: json.map(data => dataWithId(data, primaryKey)),
+        }));
+    },
+
+    getManyReference: (
+        resource,
+        params: Partial<GetManyReferenceParams> = {}
+    ) => {
+        const { page, perPage } = params.pagination;
+        const { field, order } = params.sort;
+
+        const { filter, select } = parseFilters(params, defaultListOp);
+        const primaryKey = getPrimaryKey(resource, primaryKeys);
+
+        let query = params.target
+            ? {
+                  [params.target]: `eq.${params.id}`,
+                  order: getOrderBy(field, order, primaryKey),
+                  offset: String((page - 1) * perPage),
+                  limit: String(perPage),
+                  ...filter,
+              }
+            : {
+                  order: getOrderBy(field, order, primaryKey),
+                  offset: String((page - 1) * perPage),
+                  limit: String(perPage),
+                  ...filter,
+              };
+
+        if (select) {
+            query.select = select;
+        }
+
+        // add header that Content-Range is in returned header
+        const options = {
+            headers: new Headers({
+                Accept: 'application/json',
+                Prefer: 'count=exact',
+                ...(params.meta?.headers || {}),
+            }),
+        };
+
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+
+        return httpClient(url, options).then(({ headers, json }) => {
+            if (!headers.has('content-range')) {
+                throw new Error(
+                    `The Content-Range header is missing in the HTTP Response. The postgREST data provider expects 
+          responses for lists of resources to contain this header with the total number of results to build 
+          the pagination. If you are using CORS, did you declare Content-Range in the Access-Control-Expose-Headers header?`
+                );
+            }
+            return {
+                data: json.map(data => dataWithId(data, primaryKey)),
+                total: parseInt(
+                    headers.get('content-range').split('/').pop(),
+                    10
+                ),
+            };
+        });
+    },
+
+    update: (resource, params: Partial<UpdateParams> = {}) => {
+        const { id, data, meta } = params;
+        const primaryKey = getPrimaryKey(resource, primaryKeys);
+
+        const query = getQuery(primaryKey, id, resource, meta);
+
+        const primaryKeyData = getKeyData(primaryKey, data);
+
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+
+        const body = JSON.stringify({
+            ...data,
+            ...primaryKeyData,
+        });
+
+        return httpClient(url, {
+            method: 'PATCH',
+            headers: new Headers({
+                Accept: 'application/vnd.pgrst.object+json',
+                Prefer: 'return=representation',
+                'Content-Type': 'application/json',
+                ...(params.meta?.headers || {}),
+            }),
+            body,
+        }).then(({ json }) => ({ data: dataWithId(json, primaryKey) }));
+    },
+
+    updateMany: (resource, params: Partial<UpdateManyParams> = {}) => {
+        const ids = params.ids;
+        const primaryKey = getPrimaryKey(resource, primaryKeys);
+
+        const body = JSON.stringify(
+            params.ids.map(id => {
+                const { data } = params;
+                const primaryKeyParams = decodeId(id, primaryKey);
+
+                const primaryKeyData = {};
+                if (isCompoundKey(primaryKey)) {
+                    primaryKey.forEach((key, index) => {
+                        primaryKeyData[key] = primaryKeyParams[index];
+                    });
+                } else {
+                    primaryKeyData[primaryKey[0]] = primaryKeyParams[0];
+                }
+
+                return {
+                    ...data,
+                    ...primaryKeyData,
+                };
+            })
+        );
+
+        const url = `${apiUrl}/${resource}`;
+
+        return httpClient(url, {
+            method: 'PATCH',
+            headers: new Headers({
+                Prefer: 'return=representation',
+                'Content-Type': 'application/json',
+                ...(params.meta?.headers || {}),
+            }),
+            body,
+        }).then(({ json }) => ({
+            data: json.map(data => encodeId(data, primaryKey)),
+        }));
+    },
+
+    create: (resource, params: Partial<CreateParams> = {}) => {
+        const primaryKey = getPrimaryKey(resource, primaryKeys);
+        const url = `${apiUrl}/${resource}`;
+
+        return httpClient(url, {
+            method: 'POST',
+            headers: new Headers({
+                Accept: 'application/vnd.pgrst.object+json',
+                Prefer: 'return=representation',
+                'Content-Type': 'application/json',
+                ...(params.meta?.headers || {}),
+            }),
+            body: JSON.stringify(params.data),
+        }).then(({ json }) => ({
+            data: {
+                ...json,
+                id: encodeId(json, primaryKey),
+            },
+        }));
+    },
+
+    delete: (resource, params: Partial<DeleteParams> = {}) => {
+        const { id, meta } = params;
+        const primaryKey = getPrimaryKey(resource, primaryKeys);
+
+        const query = getQuery(primaryKey, id, resource, meta);
+
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+
+        return httpClient(url, {
+            method: 'DELETE',
+            headers: new Headers({
+                Accept: 'application/vnd.pgrst.object+json',
+                Prefer: 'return=representation',
+                'Content-Type': 'application/json',
+                ...(params.meta?.headers || {}),
+            }),
+        }).then(({ json }) => ({ data: dataWithId(json, primaryKey) }));
+    },
+
+    deleteMany: (resource, params: Partial<DeleteManyParams> = {}) => {
+        const { ids, meta } = params;
+        const primaryKey = getPrimaryKey(resource, primaryKeys);
+
+        const query = getQuery(primaryKey, ids, resource, meta);
+
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+
+        return httpClient(url, {
+            method: 'DELETE',
+            headers: new Headers({
+                Prefer: 'return=representation',
+                'Content-Type': 'application/json',
+                ...(params.meta?.headers || {}),
+            }),
+        }).then(({ json }) => ({
+            data: json.map(data => encodeId(data, primaryKey)),
+        }));
+    },
+});

package/src/urlBuilder.ts

@@ -0,0 +1,248 @@
+import { Identifier } from 'ra-core';
+
+/**
+ * Interface to clearly seperate the operator like < oder >
+ * from the name and the value of the filter
+ */
+interface PostgRestFilter {
+    name: string;
+    operator?: PostgRestOperator;
+    value: string;
+}
+
+/**
+ * List of all possible operators in PostgRest
+ * (https://postgrest.org/en/stable/api.html#operators)
+ */
+const postgrestOperators = [
+    'eq',
+    'gt',
+    'gte',
+    'lt',
+    'lte',
+    'neq',
+    'like',
+    'ilike',
+    'match',
+    'imatch',
+    'in',
+    'is',
+    'fts',
+    'plfts',
+    'phfts',
+    'wfts',
+    'cs',
+    'cd',
+    'ov',
+    'sl',
+    'sr',
+    'nxr',
+    'nxl',
+    'adj',
+    'not',
+    'or',
+    'and',
+] as const;
+
+type ParsedFiltersResult = {
+    filter: any;
+    select: any;
+};
+
+export type PostgRestOperator = (typeof postgrestOperators)[number];
+
+export const parseFilters = (
+    params: any,
+    defaultListOp: PostgRestOperator
+): Partial<ParsedFiltersResult> => {
+    const { filter, meta = {} } = params;
+
+    let result: Partial<ParsedFiltersResult> = {};
+    result.filter = {};
+    Object.keys(filter).forEach(function (key) {
+        // key: the name of the object key
+
+        const splitKey = key.split('@');
+        const operation: PostgRestOperator =
+            splitKey.length == 2
+                ? (splitKey[1] as PostgRestOperator)
+                : defaultListOp;
+
+        let values: Array<string>;
+        if (['like', 'ilike'].includes(operation)) {
+            // we split the search term in words
+            values = filter[key].trim().split(/\s+/);
+        } else {
+            values = [filter[key]];
+        }
+
+        values.forEach(value => {
+            // if operator is intentionally blank, rpc syntax
+            let op = operation.includes('like')
+                ? `${operation}.*${value}*`
+                : operation.length == 0
+                ? `${value}`
+                : `${operation}.${value}`;
+
+            if (result.filter[splitKey[0]] === undefined) {
+                // first operator for the key, we add it to the dict
+                result.filter[splitKey[0]] = op;
+            } else {
+                if (!Array.isArray(result[splitKey[0]])) {
+                    // second operator, we transform to an array
+                    result.filter[splitKey[0]] = [
+                        result.filter[splitKey[0]],
+                        op,
+                    ];
+                } else {
+                    // third and subsequent, we add to array
+                    result.filter[splitKey[0]].push(op);
+                }
+            }
+        });
+    });
+
+    if (meta?.columns) {
+        result.select = Array.isArray(meta.columns)
+            ? meta.columns.join(',')
+            : meta.columns;
+    }
+
+    return result;
+};
+
+// compound keys capability
+export type PrimaryKey = Array<string>;
+
+export const getPrimaryKey = (
+    resource: string,
+    primaryKeys: Map<string, PrimaryKey>
+) => {
+    return primaryKeys.get(resource) || ['id'];
+};
+
+export const decodeId = (
+    id: Identifier,
+    primaryKey: PrimaryKey
+): string[] | number[] => {
+    if (isCompoundKey(primaryKey)) {
+        return JSON.parse(id.toString());
+    } else {
+        return [id.toString()];
+    }
+};
+
+export const encodeId = (data: any, primaryKey: PrimaryKey): Identifier => {
+    if (isCompoundKey(primaryKey)) {
+        return JSON.stringify(primaryKey.map(key => data[key]));
+    } else {
+        return data[primaryKey[0]];
+    }
+};
+
+export const dataWithId = (data: any, primaryKey: PrimaryKey) => {
+    if (JSON.stringify(primaryKey) === JSON.stringify(['id'])) {
+        return data;
+    }
+
+    return Object.assign(data, {
+        id: encodeId(data, primaryKey),
+    });
+};
+
+export const isCompoundKey = (primaryKey: PrimaryKey): Boolean => {
+    return primaryKey.length > 1;
+};
+
+export const getQuery = (
+    primaryKey: PrimaryKey,
+    ids: Identifier | Array<Identifier>,
+    resource: string,
+    meta: any = null
+): any => {
+    let result: any = {};
+    if (Array.isArray(ids) && ids.length > 1) {
+        // no standardized query with multiple ids possible for rpc endpoints which are api-exposed database functions
+        if (resource.startsWith('rpc/')) {
+            console.error(
+                "PostgREST's rpc endpoints are not intended to be handled as views. Therefore, no query generation for multiple key values implemented!"
+            );
+
+            return;
+        }
+
+        if (isCompoundKey(primaryKey)) {
+            result = {
+                or: `(${ids.map(id => {
+                    const primaryKeyParams = decodeId(id, primaryKey);
+                    return `and(${primaryKey
+                        .map((key, i) => `${key}.eq.${primaryKeyParams[i]}`)
+                        .join(',')})`;
+                })})`,
+            };
+        } else {
+            result = {
+                [primaryKey[0]]: `in.(${ids.join(',')})`,
+            };
+        }
+    } else {
+        // if ids is one Identifier
+        const id: Identifier = ids.toString();
+        const primaryKeyParams = decodeId(id, primaryKey);
+
+        if (isCompoundKey(primaryKey)) {
+            if (resource.startsWith('rpc/')) {
+                result = {};
+                primaryKey.map(
+                    (key: string, i: any) =>
+                        (result[key] = `${primaryKeyParams[i]}`)
+                );
+            } else {
+                result = {
+                    and: `(${primaryKey.map(
+                        (key: string, i: any) =>
+                            `${key}.eq.${primaryKeyParams[i]}`
+                    )})`,
+                };
+            }
+        } else {
+            result = {
+                [primaryKey[0]]: `eq.${id}`,
+            };
+        }
+    }
+
+    if (meta && meta.columns) {
+        result.select = Array.isArray(meta.columns)
+            ? meta.columns.join(',')
+            : meta.columns;
+    }
+
+    return result;
+};
+
+export const getKeyData = (primaryKey: PrimaryKey, data: object): object => {
+    if (isCompoundKey(primaryKey)) {
+        return primaryKey.reduce(
+            (keyData, key) => ({
+                ...keyData,
+                [key]: data[key],
+            }),
+            {}
+        );
+    } else {
+        return { [primaryKey[0]]: data[primaryKey[0]] };
+    }
+};
+
+export const getOrderBy = (
+    field: string,
+    order: string,
+    primaryKey: PrimaryKey
+) => {
+    if (field == 'id') {
+        return primaryKey.map(key => `${key}.${order.toLowerCase()}`).join(',');
+    } else {
+        return `${field}.${order.toLowerCase()}`;
+    }
+};

package/esm/authProvider/index.d.ts

@@ -1,11 +0,0 @@
-declare const _default: {
-    login: ({ username, password }: {
-        username: any;
-        password: any;
-    }) => Promise<void>;
-    logout: (params: any) => Promise<void>;
-    checkAuth: (params: any) => Promise<void>;
-    checkError: (error: any) => Promise<void>;
-    getPermissions: (params: any) => Promise<any>;
-};
-export default _default;

package/esm/authProvider/index.js

@@ -1,58 +0,0 @@
-export default {
-    login: function (_a) {
-        var username = _a.username, password = _a.password;
-        var request = new Request('rest/rpc/login', {
-            method: 'POST',
-            body: JSON.stringify({ email: username, password: password }),
-            headers: new Headers({
-                'Content-Type': 'application/json',
-                'Accept': 'application/vnd.pgrst.object+json',
-                'Prefer': 'return=representation'
-            }),
-        });
-        return fetch(request)
-            .then(function (response) {
-            if (response.status < 200 || response.status >= 300) {
-                throw new Error(response.statusText);
-            }
-            return response.json();
-        })
-            .then(function (data) {
-            localStorage.setItem('me', JSON.stringify(data));
-        });
-    },
-    logout: function (params) {
-        var request = new Request('rest/rpc/logout', {
-            method: 'POST',
-            headers: new Headers({
-                'Content-Type': 'application/json',
-                'Accept': 'application/vnd.pgrst.object+json',
-                'Prefer': 'return=representation'
-            }),
-        });
-        return fetch(request)
-            .then(function (response) {
-            if (response.status < 200 || response.status >= 300) {
-                throw new Error(response.statusText);
-            }
-            return response.json();
-        })
-            .then(function (data) {
-            localStorage.removeItem('me');
-        });
-    },
-    checkAuth: function (params) { return (localStorage.getItem('me') ? Promise.resolve() : Promise.reject()); },
-    checkError: function (error) {
-        var status = error.status;
-        if (status === 401 || status === 403) {
-            localStorage.removeItem('me');
-            return Promise.reject();
-        }
-        return Promise.resolve();
-    },
-    getPermissions: function (params) {
-        var _a;
-        var role = (_a = JSON.parse(localStorage.getItem('me'))) === null || _a === void 0 ? void 0 : _a.role;
-        return role ? Promise.resolve(role) : Promise.reject();
-    },
-};

package/esm/dataProvider/index.d.ts

@@ -1,9 +0,0 @@
-import { fetchUtils, DataProvider } from 'ra-core';
-type PrimaryKey = Array<string>;
-declare const _default: (apiUrl: any, httpClient?: (url: any, options?: fetchUtils.Options) => Promise<{
-    status: number;
-    headers: Headers;
-    body: string;
-    json: any;
-}>, defaultListOp?: string, primaryKeys?: Map<string, PrimaryKey>) => DataProvider;
-export default _default;