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

package/src/index.ts

@@ -1,5 +1,4 @@
 import {
-    fetchUtils,
     DataProvider,
     GetListParams,
     GetOneParams,
@@ -17,12 +16,11 @@ import {
     getPrimaryKey,
     parseFilters,
     getOrderBy,
-    dataWithId,
+    dataWithVirtualId,
+    dataWithoutVirtualId,
+    removePrimaryKey,
     getQuery,
-    getKeyData,
     encodeId,
-    decodeId,
-    isCompoundKey,
 } from './urlBuilder';
 import qs from 'qs';
 
@@ -48,13 +46,24 @@ import qs from 'qs';
  * @example
  *
  * import * as React from 'react';
- * import { Admin, Resource } from 'react-admin';
- * import postgrestRestProvider from '@raphiniert/ra-data-postgrest';
+ * import { Admin, Resource, fetchUtils } from 'react-admin';
+ * import postgrestRestProvider,
+ *      { IDataProviderConfig,
+ *        defaultPrimaryKeys,
+ *        defaultSchema } from '@raphiniert/ra-data-postgrest';
  *
  * import { PostList } from './posts';
  *
+ * const config: IDataProviderConfig = {
+ *     apiUrl: 'http://path.to.my.api/',
+ *     httpClient: fetchUtils.fetchJson,
+ *     defaultListOp: 'eq',
+ *     primaryKeys: defaultPrimaryKeys,
+ *     schema: defaultSchema
+ * }
+ *
  * const App = () => (
- *     <Admin dataProvider={postgrestRestProvider('http://path.to.my.api/')}>
+ *     <Admin dataProvider={postgrestRestProvider(config)}>
  *         <Resource name="posts" list={PostList} />
  *     </Admin>
  * );
@@ -62,20 +71,50 @@ import qs from 'qs';
  * 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 => ({
+export type MetaOption = string | undefined;
+
+export const defaultPrimaryKeys = new Map<string, PrimaryKey>();
+
+export const defaultSchema = () => '';
+
+export interface IDataProviderConfig {
+    apiUrl: string;
+    httpClient: (string, Options) => Promise<any>;
+    defaultListOp: PostgRestOperator;
+    primaryKeys: Map<string, PrimaryKey>;
+    schema: () => string;
+}
+
+const useCustomSchema = (
+    schema: () => string,
+    metaSchema: MetaOption,
+    method: string
+) => {
+    let funcHeaderSchema = schema;
+    if (metaSchema !== undefined) {
+        funcHeaderSchema = () => metaSchema;
+    }
+
+    if (funcHeaderSchema().length > 0) {
+        let schemaHeader = '';
+        if (['GET', 'HEAD'].includes(method)) {
+            schemaHeader = 'Accept-Profile';
+        } else if (['POST', 'PATCH', 'PUT', 'DELETE'].includes(method)) {
+            schemaHeader = 'Content-Profile';
+        } else return {};
+
+        return { [schemaHeader]: funcHeaderSchema() };
+    } else return {};
+};
+
+export default (config: IDataProviderConfig): DataProvider => ({
     getList: (resource, params: Partial<GetListParams> = {}) => {
-        const primaryKey = getPrimaryKey(resource, primaryKeys);
+        const primaryKey = getPrimaryKey(resource, config.primaryKeys);
 
         const { page, perPage } = params.pagination;
         const { field, order } = params.sort || {};
-        const { filter, select } = parseFilters(params, defaultListOp);
+        const { filter, select } = parseFilters(params, config.defaultListOp);
+        const metaSchema = params.meta?.schema;
 
         let query = {
             offset: String((page - 1) * perPage),
@@ -98,12 +137,13 @@ export default (
                 Accept: 'application/json',
                 Prefer: 'count=exact',
                 ...(params.meta?.headers || {}),
+                ...useCustomSchema(config.schema, metaSchema, 'GET'),
             }),
         };
 
-        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+        const url = `${config.apiUrl}/${resource}?${qs.stringify(query)}`;
 
-        return httpClient(url, options).then(({ headers, json }) => {
+        return config.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 
@@ -112,7 +152,7 @@ export default (
                 );
             }
             return {
-                data: json.map(obj => dataWithId(obj, primaryKey)),
+                data: json.map(obj => dataWithVirtualId(obj, primaryKey)),
                 total: parseInt(
                     headers.get('content-range').split('/').pop(),
                     10
@@ -123,32 +163,44 @@ export default (
 
     getOne: (resource, params: Partial<GetOneParams> = {}) => {
         const { id, meta } = params;
-        const primaryKey = getPrimaryKey(resource, primaryKeys);
+        const primaryKey = getPrimaryKey(resource, config.primaryKeys);
 
         const query = getQuery(primaryKey, id, resource, meta);
 
-        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+        const url = `${config.apiUrl}/${resource}?${qs.stringify(query)}`;
+        const metaSchema = params.meta?.schema;
 
-        return httpClient(url, {
-            headers: new Headers({
-                accept: 'application/vnd.pgrst.object+json',
-                ...(params.meta?.headers || {}),
-            }),
-        }).then(({ json }) => ({
-            data: dataWithId(json, primaryKey),
-        }));
+        return config
+            .httpClient(url, {
+                headers: new Headers({
+                    accept: 'application/vnd.pgrst.object+json',
+                    ...(params.meta?.headers || {}),
+                    ...useCustomSchema(config.schema, metaSchema, 'GET'),
+                }),
+            })
+            .then(({ json }) => ({
+                data: dataWithVirtualId(json, primaryKey),
+            }));
     },
 
     getMany: (resource, params: Partial<GetManyParams> = {}) => {
         const ids = params.ids;
-        const primaryKey = getPrimaryKey(resource, primaryKeys);
+        const primaryKey = getPrimaryKey(resource, config.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)),
-        }));
+        const url = `${config.apiUrl}/${resource}?${qs.stringify(query)}`;
+        const metaSchema = params.meta?.schema;
+
+        return config
+            .httpClient(url, {
+                headers: new Headers({
+                    ...useCustomSchema(config.schema, metaSchema, 'GET'),
+                }),
+            })
+            .then(({ json }) => ({
+                data: json.map(data => dataWithVirtualId(data, primaryKey)),
+            }));
     },
 
     getManyReference: (
@@ -158,8 +210,10 @@ export default (
         const { page, perPage } = params.pagination;
         const { field, order } = params.sort;
 
-        const { filter, select } = parseFilters(params, defaultListOp);
-        const primaryKey = getPrimaryKey(resource, primaryKeys);
+        const { filter, select } = parseFilters(params, config.defaultListOp);
+        const primaryKey = getPrimaryKey(resource, config.primaryKeys);
+
+        const metaSchema = params.meta?.schema;
 
         let query = params.target
             ? {
@@ -186,12 +240,13 @@ export default (
                 Accept: 'application/json',
                 Prefer: 'count=exact',
                 ...(params.meta?.headers || {}),
+                ...useCustomSchema(config.schema, metaSchema, 'GET'),
             }),
         };
 
-        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+        const url = `${config.apiUrl}/${resource}?${qs.stringify(query)}`;
 
-        return httpClient(url, options).then(({ headers, json }) => {
+        return config.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 
@@ -200,7 +255,7 @@ export default (
                 );
             }
             return {
-                data: json.map(data => dataWithId(data, primaryKey)),
+                data: json.map(data => dataWithVirtualId(data, primaryKey)),
                 total: parseInt(
                     headers.get('content-range').split('/').pop(),
                     10
@@ -211,128 +266,143 @@ export default (
 
     update: (resource, params: Partial<UpdateParams> = {}) => {
         const { id, data, meta } = params;
-        const primaryKey = getPrimaryKey(resource, primaryKeys);
-
+        const primaryKey = getPrimaryKey(resource, config.primaryKeys);
         const query = getQuery(primaryKey, id, resource, meta);
-
-        const primaryKeyData = getKeyData(primaryKey, data);
-
-        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
+        const url = `${config.apiUrl}/${resource}?${qs.stringify(query)}`;
+        const metaSchema = params.meta?.schema;
 
         const body = JSON.stringify({
-            ...data,
-            ...primaryKeyData,
+            ...dataWithoutVirtualId(
+                removePrimaryKey(data, primaryKey),
+                primaryKey
+            ),
         });
 
-        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) }));
+        return config
+            .httpClient(url, {
+                method: 'PATCH',
+                headers: new Headers({
+                    Accept: 'application/vnd.pgrst.object+json',
+                    Prefer: 'return=representation',
+                    'Content-Type': 'application/json',
+                    ...(params.meta?.headers || {}),
+                    ...useCustomSchema(config.schema, metaSchema, 'PATCH'),
+                }),
+                body,
+            })
+            .then(({ json }) => ({
+                data: dataWithVirtualId(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}`;
+        const { ids, meta, data } = params;
+        const primaryKey = getPrimaryKey(resource, config.primaryKeys);
+        const query = getQuery(primaryKey, ids, resource, meta);
+        const url = `${config.apiUrl}/${resource}?${qs.stringify(query)}`;
+        const body = JSON.stringify({
+            ...dataWithoutVirtualId(
+                removePrimaryKey(data, primaryKey),
+                primaryKey
+            ),
+        });
 
-        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)),
-        }));
+        const metaSchema = params.meta?.schema;
+
+        return config
+            .httpClient(url, {
+                method: 'PATCH',
+                headers: new Headers({
+                    Prefer: 'return=representation',
+                    'Content-Type': 'application/json',
+                    ...(params.meta?.headers || {}),
+                    ...useCustomSchema(config.schema, metaSchema, 'PATCH'),
+                }),
+                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),
-            },
-        }));
+        const { meta } = params;
+        const primaryKey = getPrimaryKey(resource, config.primaryKeys);
+        const query = getQuery(primaryKey, undefined, resource, meta);
+        const queryStr = qs.stringify(query);
+        const url = `${config.apiUrl}/${resource}${
+            queryStr.length > 0 ? '?' : ''
+        }${queryStr}`;
+        const metaSchema = params.meta?.schema;
+
+        return config
+            .httpClient(url, {
+                method: 'POST',
+                headers: new Headers({
+                    Accept: 'application/vnd.pgrst.object+json',
+                    Prefer: 'return=representation',
+                    'Content-Type': 'application/json',
+                    ...(params.meta?.headers || {}),
+                    ...useCustomSchema(config.schema, metaSchema, 'POST'),
+                }),
+                body: JSON.stringify(
+                    dataWithoutVirtualId(params.data, primaryKey)
+                ),
+            })
+            .then(({ json }) => ({
+                data: {
+                    ...json,
+                    id: encodeId(json, primaryKey),
+                },
+            }));
     },
 
     delete: (resource, params: Partial<DeleteParams> = {}) => {
         const { id, meta } = params;
-        const primaryKey = getPrimaryKey(resource, primaryKeys);
+        const primaryKey = getPrimaryKey(resource, config.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) }));
+        const url = `${config.apiUrl}/${resource}?${qs.stringify(query)}`;
+        const metaSchema = params.meta?.schema;
+
+        return config
+            .httpClient(url, {
+                method: 'DELETE',
+                headers: new Headers({
+                    Accept: 'application/vnd.pgrst.object+json',
+                    Prefer: 'return=representation',
+                    'Content-Type': 'application/json',
+                    ...(params.meta?.headers || {}),
+                    ...useCustomSchema(config.schema, metaSchema, 'DELETE'),
+                }),
+            })
+            .then(({ json }) => ({
+                data: dataWithVirtualId(json, primaryKey),
+            }));
     },
 
     deleteMany: (resource, params: Partial<DeleteManyParams> = {}) => {
         const { ids, meta } = params;
-        const primaryKey = getPrimaryKey(resource, primaryKeys);
+        const primaryKey = getPrimaryKey(resource, config.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)),
-        }));
+        const url = `${config.apiUrl}/${resource}?${qs.stringify(query)}`;
+        const metaSchema = params.meta?.schema;
+
+        return config
+            .httpClient(url, {
+                method: 'DELETE',
+                headers: new Headers({
+                    Prefer: 'return=representation',
+                    'Content-Type': 'application/json',
+                    ...(params.meta?.headers || {}),
+                    ...useCustomSchema(config.schema, metaSchema, 'DELETE'),
+                }),
+            })
+            .then(({ json }) => ({
+                data: json.map(data => encodeId(data, primaryKey)),
+            }));
     },
 });

package/src/urlBuilder.ts

@@ -49,6 +49,18 @@ type ParsedFiltersResult = {
     select: any;
 };
 
+const isObject = obj =>
+    typeof obj === 'object' && !Array.isArray(obj) && obj !== null;
+
+const resolveKeys = (filter: any, keys: Array<any>) => {
+    let result = filter[keys[0]];
+    for (let i = 1; i < keys.length; ++i) {
+        result = result[keys[i]];
+    }
+
+    return result;
+};
+
 export type PostgRestOperator = (typeof postgrestOperators)[number];
 
 export const parseFilters = (
@@ -62,31 +74,81 @@ export const parseFilters = (
     Object.keys(filter).forEach(function (key) {
         // key: the name of the object key
 
+        let keyArray = [key];
+        let values: Array<string>;
+
+        // in case of a nested object selection in a text field
+        // RA returns object{ object } structure which is resolved here
+        // see issue https://github.com/raphiniert-com/ra-data-postgrest/issues/58
+        if (key.split('@')[0] !== '' && isObject(filter[key])) {
+            let innerVal = filter[key];
+
+            do {
+                const inner = resolveKeys(filter, keyArray);
+                const [innerKey] = Object.keys(inner);
+
+                keyArray.push(innerKey);
+                innerVal = inner[innerKey];
+            } while (isObject(innerVal));
+
+            key = keyArray.join('.');
+            values = [innerVal];
+        } else {
+            values = [filter[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 = resolveKeys(filter, keyArray).trim().split(/\s+/);
+        }
+        // CASE: Logical operator
+        else if (['or', 'and'].includes(operation)) {
+            // we extract each value entries and make it dot separated string.
+            const { filter: subFilter } = parseFilters(
+                { filter: resolveKeys(filter, keyArray) },
+                defaultListOp
+            );
+
+            // something like { "age@lt": 18 } and { "age@gt": 21 }
+            const filterExpressions: string[] = [];
+            Object.entries(subFilter).forEach(([op, val]) => {
+                if (Array.isArray(val))
+                    filterExpressions.push(...val.map(v => [op, v].join('.')));
+                else filterExpressions.push([op, val].join('.'));
+            });
+
+            // finally we flatten all as single string and enclose with bracket.
+            values = [`(${filterExpressions.join(',')})`];
         }
 
         values.forEach(value => {
-            // if operator is intentionally blank, rpc syntax
-            let op = operation.includes('like')
-                ? `${operation}.*${value}*`
-                : operation.length == 0
-                ? `${value}`
-                : `${operation}.${value}`;
+            let op: string = (() => {
+                // if operator is intentionally blank, rpc syntax
+                if (operation.length === 0) return `${value}`;
+
+                if (operation.includes('like'))
+                    return `${operation}.*${value}*`;
+                if (['and', 'or'].includes(operation)) return `${value}`;
+                if (['cs', 'cd'].includes(operation))
+                    return `${operation}.{${value}}`;
+                return `${operation}.${value}`;
+            })();
 
+            // If resulting filter doesn't contain the fieldname, then add it.
             if (result.filter[splitKey[0]] === undefined) {
-                // first operator for the key, we add it to the dict
-                result.filter[splitKey[0]] = op;
+                // first operator for the key,
+                if (['and', 'or'].includes(operation)) {
+                    result.filter[operation] = op;
+                } else {
+                    // 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
@@ -140,8 +202,16 @@ export const encodeId = (data: any, primaryKey: PrimaryKey): Identifier => {
     }
 };
 
-export const dataWithId = (data: any, primaryKey: PrimaryKey) => {
-    if (JSON.stringify(primaryKey) === JSON.stringify(['id'])) {
+export const removePrimaryKey = (data: any, primaryKey: PrimaryKey) => {
+    const newData = { ...data };
+    primaryKey.forEach(key => {
+        delete newData[key];
+    });
+    return newData;
+};
+
+export const dataWithVirtualId = (data: any, primaryKey: PrimaryKey) => {
+    if (primaryKey.length === 1 && primaryKey[0] === 'id') {
         return data;
     }
 
@@ -150,13 +220,22 @@ export const dataWithId = (data: any, primaryKey: PrimaryKey) => {
     });
 };
 
-export const isCompoundKey = (primaryKey: PrimaryKey): Boolean => {
+export const dataWithoutVirtualId = (data: any, primaryKey: PrimaryKey) => {
+    if (primaryKey.length === 1 && primaryKey[0] === 'id') {
+        return data;
+    }
+
+    const { id, ...dataWithoutId } = data;
+    return dataWithoutId;
+};
+
+const isCompoundKey = (primaryKey: PrimaryKey): Boolean => {
     return primaryKey.length > 1;
 };
 
 export const getQuery = (
     primaryKey: PrimaryKey,
-    ids: Identifier | Array<Identifier>,
+    ids: Identifier | Array<Identifier> | undefined,
     resource: string,
     meta: any = null
 ): any => {
@@ -185,7 +264,7 @@ export const getQuery = (
                 [primaryKey[0]]: `in.(${ids.join(',')})`,
             };
         }
-    } else {
+    } else if (ids) {
         // if ids is one Identifier
         const id: Identifier = ids.toString();
         const primaryKeyParams = decodeId(id, primaryKey);
@@ -221,20 +300,6 @@ export const getQuery = (
     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,