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

package/esm/urlBuilder.js

@@ -9,6 +9,17 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 /**
  * List of all possible operators in PostgRest
  * (https://postgrest.org/en/stable/api.html#operators)
@@ -42,34 +53,88 @@ var postgrestOperators = [
     'or',
     'and',
 ];
+var isObject = function (obj) {
+    return typeof obj === 'object' && !Array.isArray(obj) && obj !== null;
+};
+var resolveKeys = function (filter, keys) {
+    var result = filter[keys[0]];
+    for (var i = 1; i < keys.length; ++i) {
+        result = result[keys[i]];
+    }
+    return result;
+};
 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 keyArray = [key];
+        var values;
+        // 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])) {
+            var innerVal = filter[key];
+            do {
+                var inner = resolveKeys(filter, keyArray);
+                var innerKey = Object.keys(inner)[0];
+                keyArray.push(innerKey);
+                innerVal = inner[innerKey];
+            } while (isObject(innerVal));
+            key = keyArray.join('.');
+            values = [innerVal];
+        }
+        else {
+            values = [filter[key]];
+        }
         var splitKey = key.split('@');
         var operation = splitKey.length == 2
             ? splitKey[1]
             : defaultListOp;
-        var values;
         if (['like', 'ilike'].includes(operation)) {
             // we split the search term in words
-            values = filter[key].trim().split(/\s+/);
+            values = resolveKeys(filter, keyArray).trim().split(/\s+/);
         }
-        else {
-            values = [filter[key]];
+        // CASE: Logical operator
+        else if (['or', 'and'].includes(operation)) {
+            // we extract each value entries and make it dot separated string.
+            var subFilter = parseFilters({ filter: resolveKeys(filter, keyArray) }, 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(','), ")")];
         }
         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);
+            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 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]])) {
@@ -112,15 +177,29 @@ export var encodeId = function (data, primaryKey) {
         return data[primaryKey[0]];
     }
 };
-export var dataWithId = function (data, primaryKey) {
-    if (JSON.stringify(primaryKey) === JSON.stringify(['id'])) {
+export var removePrimaryKey = function (data, primaryKey) {
+    var newData = __assign({}, data);
+    primaryKey.forEach(function (key) {
+        delete newData[key];
+    });
+    return newData;
+};
+export var dataWithVirtualId = function (data, primaryKey) {
+    if (primaryKey.length === 1 && primaryKey[0] === 'id') {
         return data;
     }
     return Object.assign(data, {
         id: encodeId(data, primaryKey),
     });
 };
-export var isCompoundKey = function (primaryKey) {
+export var dataWithoutVirtualId = function (data, primaryKey) {
+    if (primaryKey.length === 1 && primaryKey[0] === 'id') {
+        return data;
+    }
+    var id = data.id, dataWithoutId = __rest(data, ["id"]);
+    return dataWithoutId;
+};
+var isCompoundKey = function (primaryKey) {
     return primaryKey.length > 1;
 };
 export var getQuery = function (primaryKey, ids, resource, meta) {
@@ -149,7 +228,7 @@ export var getQuery = function (primaryKey, ids, resource, meta) {
                 _a);
         }
     }
-    else {
+    else if (ids) {
         // if ids is one Identifier
         var id = ids.toString();
         var primaryKeyParams_1 = decodeId(id, primaryKey);
@@ -181,18 +260,6 @@ export var getQuery = function (primaryKey, ids, resource, meta) {
     }
     return result;
 };
-export var getKeyData = function (primaryKey, data) {
-    var _a;
-    if (isCompoundKey(primaryKey)) {
-        return primaryKey.reduce(function (keyData, key) {
-            var _a;
-            return (__assign(__assign({}, keyData), (_a = {}, _a[key] = data[key], _a)));
-        }, {});
-    }
-    else {
-        return _a = {}, _a[primaryKey[0]] = data[primaryKey[0]], _a;
-    }
-};
 export var getOrderBy = function (field, order, primaryKey) {
     if (field == 'id') {
         return primaryKey.map(function (key) { return "".concat(key, ".").concat(order.toLowerCase()); }).join(',');

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;