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

package/esm/urlBuilder.js

@@ -42,8 +42,10 @@ var postgrestOperators = [
     'or',
     'and',
 ];
-export var parseFilters = function (filter, defaultListOp) {
+export var parseFilters = function (params, defaultListOp) {
+    var filter = params.filter, _a = params.meta, meta = _a === void 0 ? {} : _a;
     var result = {};
+    result.filter = {};
     Object.keys(filter).forEach(function (key) {
         // key: the name of the object key
         var splitKey = key.split('@');
@@ -55,32 +57,69 @@ export var parseFilters = function (filter, defaultListOp) {
             // 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.
+            var subFilter = parseFilters({ filter: filter[key] }, defaultListOp).filter;
+            // something like { "age@lt": 18 } and { "age@gt": 21 }
+            var filterExpressions_1 = [];
+            Object.entries(subFilter).forEach(function (_a) {
+                var op = _a[0], val = _a[1];
+                if (Array.isArray(val))
+                    filterExpressions_1.push.apply(filterExpressions_1, val.map(function (v) { return [op, v].join('.'); }));
+                else
+                    filterExpressions_1.push([op, val].join('.'));
+            });
+            // finally we flatten all as single string and enclose with bracket.
+            values = ["(".concat(filterExpressions_1.join(','), ")")];
+        }
         else {
             values = [filter[key]];
         }
         values.forEach(function (value) {
-            // if operator is intentionally blank, rpc syntax
-            var op = operation.includes('like')
-                ? "".concat(operation, ".*").concat(value, "*")
-                : operation.length == 0
-                    ? "".concat(value)
-                    : "".concat(operation, ".").concat(value);
-            if (result[splitKey[0]] === undefined) {
-                // first operator for the key, we add it to the dict
-                result[splitKey[0]] = op;
+            var op = (function () {
+                // if operator is intentionally blank, rpc syntax
+                if (operation.length === 0)
+                    return "".concat(value);
+                if (operation.includes('like'))
+                    return "".concat(operation, ".*").concat(value, "*");
+                if (['and', 'or'].includes(operation))
+                    return "".concat(value);
+                if (['cs', 'cd'].includes(operation))
+                    return "".concat(operation, ".{").concat(value, "}");
+                return "".concat(operation, ".").concat(value);
+            })();
+            // If resulting filter haven't contains the fieldname, then add it.
+            if (result.filter[splitKey[0]] === undefined) {
+                // 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
-                    result[splitKey[0]] = [result[splitKey[0]], op];
+                    result.filter[splitKey[0]] = [
+                        result.filter[splitKey[0]],
+                        op,
+                    ];
                 }
                 else {
                     // third and subsequent, we add to array
-                    result[splitKey[0]].push(op);
+                    result.filter[splitKey[0]].push(op);
                 }
             }
         });
     });
+    if (meta === null || meta === void 0 ? void 0 : meta.columns) {
+        result.select = Array.isArray(meta.columns)
+            ? meta.columns.join(',')
+            : meta.columns;
+    }
     return result;
 };
 export var getPrimaryKey = function (resource, primaryKeys) {
@@ -113,8 +152,10 @@ export var dataWithId = function (data, primaryKey) {
 export var isCompoundKey = function (primaryKey) {
     return primaryKey.length > 1;
 };
-export var getQuery = function (primaryKey, ids, resource) {
-    var _a;
+export var getQuery = function (primaryKey, ids, resource, meta) {
+    var _a, _b;
+    if (meta === void 0) { meta = null; }
+    var result = {};
     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/')) {
@@ -122,18 +163,19 @@ export var getQuery = function (primaryKey, ids, resource) {
             return;
         }
         if (isCompoundKey(primaryKey)) {
-            // TODO: Should be URL encoded
-            return "or=(".concat(ids.map(function (id) {
-                var primaryKeyParams = decodeId(id, primaryKey);
-                return "and(".concat(primaryKey
-                    .map(function (key, i) { return "".concat(key, ".eq.").concat(primaryKeyParams[i]); })
-                    .join(','), ")");
-            }), ")");
+            result = {
+                or: "(".concat(ids.map(function (id) {
+                    var primaryKeyParams = decodeId(id, primaryKey);
+                    return "and(".concat(primaryKey
+                        .map(function (key, i) { return "".concat(key, ".eq.").concat(primaryKeyParams[i]); })
+                        .join(','), ")");
+                }), ")"),
+            };
         }
         else {
-            return new URLSearchParams((_a = {},
+            result = (_a = {},
                 _a[primaryKey[0]] = "in.(".concat(ids.join(','), ")"),
-                _a)).toString();
+                _a);
         }
     }
     else {
@@ -141,25 +183,32 @@ export var getQuery = function (primaryKey, ids, resource) {
         var id = ids.toString();
         var primaryKeyParams_1 = decodeId(id, primaryKey);
         if (isCompoundKey(primaryKey)) {
-            if (resource.startsWith('rpc/'))
-                // TODO: Should be URL encoded
-                return "".concat(primaryKey
-                    .map(function (key, i) { return "".concat(key, "=").concat(primaryKeyParams_1[i]); })
-                    .join('&'));
-            // TODO: Should be URL encoded
-            else
-                return "and=(".concat(primaryKey
-                    .map(function (key, i) {
-                    return "".concat(key, ".eq.").concat(primaryKeyParams_1[i]);
-                })
-                    .join(','), ")");
+            if (resource.startsWith('rpc/')) {
+                result = {};
+                primaryKey.map(function (key, i) {
+                    return (result[key] = "".concat(primaryKeyParams_1[i]));
+                });
+            }
+            else {
+                result = {
+                    and: "(".concat(primaryKey.map(function (key, i) {
+                        return "".concat(key, ".eq.").concat(primaryKeyParams_1[i]);
+                    }), ")"),
+                };
+            }
         }
         else {
-            return new URLSearchParams([
-                [primaryKey[0], "eq.".concat(id)],
-            ]).toString();
+            result = (_b = {},
+                _b[primaryKey[0]] = "eq.".concat(id),
+                _b);
         }
     }
+    if (meta && meta.columns) {
+        result.select = Array.isArray(meta.columns)
+            ? meta.columns.join(',')
+            : meta.columns;
+    }
+    return result;
 };
 export var getKeyData = function (primaryKey, data) {
     var _a;

package/lib/index.d.ts

@@ -1,9 +1,60 @@
-import { fetchUtils, DataProvider } from 'ra-core';
+import { DataProvider } from 'ra-core';
 import { PrimaryKey, PostgRestOperator } from './urlBuilder';
-declare const _default: (apiUrl: string, httpClient?: (url: any, options?: fetchUtils.Options) => Promise<{
-    status: number;
-    headers: Headers;
-    body: string;
-    json: any;
-}>, defaultListOp?: PostgRestOperator, primaryKeys?: Map<string, PrimaryKey>) => 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, 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(config)}>
+ *         <Resource name="posts" list={PostList} />
+ *     </Admin>
+ * );
+ *
+ * export default App;
+ */
+export type MetaOption = string | undefined;
+export declare const defaultPrimaryKeys: Map<string, PrimaryKey>;
+export declare const defaultSchema: () => string;
+export interface IDataProviderConfig {
+    apiUrl: string;
+    httpClient: (string: any, Options: any) => Promise<any>;
+    defaultListOp: PostgRestOperator;
+    primaryKeys: Map<string, PrimaryKey>;
+    schema: () => string;
+}
+declare const _default: (config: IDataProviderConfig) => DataProvider;
 export default _default;