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

package/src/index.ts

@@ -48,13 +48,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 +73,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 +139,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 
@@ -123,32 +165,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: dataWithId(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 => dataWithId(data, primaryKey)),
+            }));
     },
 
     getManyReference: (
@@ -158,8 +212,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 +242,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 
@@ -211,34 +268,38 @@ 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,
         });
 
-        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: dataWithId(json, primaryKey) }));
     },
 
     updateMany: (resource, params: Partial<UpdateManyParams> = {}) => {
         const ids = params.ids;
-        const primaryKey = getPrimaryKey(resource, primaryKeys);
+        const primaryKey = getPrimaryKey(resource, config.primaryKeys);
 
         const body = JSON.stringify(
             params.ids.map(id => {
@@ -261,78 +322,94 @@ export default (
             })
         );
 
-        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)),
-        }));
+        const url = `${config.apiUrl}/${resource}`;
+        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 primaryKey = getPrimaryKey(resource, config.primaryKeys);
+        const url = `${config.apiUrl}/${resource}`;
+        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(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 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: dataWithId(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

@@ -72,21 +72,51 @@ export const parseFilters = (
         if (['like', 'ilike'].includes(operation)) {
             // we split the search term in words
             values = filter[key].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: filter[key] },
+                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(',')})`];
         } 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}`;
+            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 haven't contains 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