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

package/lib/urlBuilder.d.ts

@@ -4,15 +4,19 @@ import { Identifier } from 'ra-core';
  * (https://postgrest.org/en/stable/api.html#operators)
  */
 declare const postgrestOperators: readonly ["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"];
-export type PostgRestOperator = typeof postgrestOperators[number];
-export declare const parseFilters: (filter: Record<string, any>, defaultListOp: PostgRestOperator) => {};
+type ParsedFiltersResult = {
+    filter: any;
+    select: any;
+};
+export type PostgRestOperator = (typeof postgrestOperators)[number];
+export declare const parseFilters: (params: any, defaultListOp: PostgRestOperator) => Partial<ParsedFiltersResult>;
 export type PrimaryKey = Array<string>;
 export declare const getPrimaryKey: (resource: string, primaryKeys: Map<string, PrimaryKey>) => PrimaryKey;
 export declare const decodeId: (id: Identifier, primaryKey: PrimaryKey) => string[] | number[];
 export declare const encodeId: (data: any, primaryKey: PrimaryKey) => Identifier;
 export declare const dataWithId: (data: any, primaryKey: PrimaryKey) => any;
 export declare const isCompoundKey: (primaryKey: PrimaryKey) => Boolean;
-export declare const getQuery: (primaryKey: PrimaryKey, ids: Identifier | Array<Identifier>, resource: string) => string;
+export declare const getQuery: (primaryKey: PrimaryKey, ids: Identifier | Array<Identifier>, resource: string, meta?: any) => any;
 export declare const getKeyData: (primaryKey: PrimaryKey, data: object) => object;
 export declare const getOrderBy: (field: string, order: string, primaryKey: PrimaryKey) => string;
 export {};

package/lib/urlBuilder.js

@@ -45,8 +45,10 @@ var postgrestOperators = [
     'or',
     'and',
 ];
-var parseFilters = function (filter, defaultListOp) {
+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('@');
@@ -68,22 +70,30 @@ var parseFilters = function (filter, defaultListOp) {
                 : operation.length == 0
                     ? "".concat(value)
                     : "".concat(operation, ".").concat(value);
-            if (result[splitKey[0]] === undefined) {
+            if (result.filter[splitKey[0]] === undefined) {
                 // first operator for the key, we add it to the dict
-                result[splitKey[0]] = op;
+                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;
 };
 exports.parseFilters = parseFilters;
@@ -122,8 +132,10 @@ var isCompoundKey = function (primaryKey) {
     return primaryKey.length > 1;
 };
 exports.isCompoundKey = isCompoundKey;
-var getQuery = function (primaryKey, ids, resource) {
-    var _a;
+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/')) {
@@ -131,18 +143,19 @@ var getQuery = function (primaryKey, ids, resource) {
             return;
         }
         if ((0, exports.isCompoundKey)(primaryKey)) {
-            // TODO: Should be URL encoded
-            return "or=(".concat(ids.map(function (id) {
-                var primaryKeyParams = (0, exports.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 = (0, exports.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 {
@@ -150,25 +163,32 @@ var getQuery = function (primaryKey, ids, resource) {
         var id = ids.toString();
         var primaryKeyParams_1 = (0, exports.decodeId)(id, primaryKey);
         if ((0, exports.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;
 };
 exports.getQuery = getQuery;
 var getKeyData = function (primaryKey, data) {

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@raphiniert/ra-data-postgrest",
-    "version": "2.0.0-alpha.0",
+    "version": "2.0.0-alpha.1",
     "description": "postgREST data provider for react-admin",
     "main": "lib/index.js",
     "module": "esm/index.js",
@@ -20,7 +20,8 @@
     "bugs": "https://github.com/raphiniert-com/ra-data-postgrest/issues",
     "license": "MIT",
     "scripts": {
-        "test": "jest --watch",
+        "coverage": "jest --coverage",
+        "test": "jest --watchAll",
         "build": "npm run build-cjs && npm run build-esm",
         "build-cjs": "rimraf ./lib && tsc",
         "build-esm": "rimraf ./esm && tsc --outDir esm --module es2015",
@@ -31,16 +32,19 @@
     "devDependencies": {
         "@types/jest": "^28.1.4",
         "cross-env": "^7.0.3",
-        "eslint-config-prettier": "^8.5.0",
+        "eslint-config-prettier": "^8.8.0",
         "eslint-plugin-prettier": "^4.2.1",
         "install-peers-cli": "^2.2.0",
         "jest": "^28.1.2",
-        "prettier": "~2.1.1",
-        "rimraf": "^3.0.2",
+        "prettier": "~2.8.7",
+        "rimraf": "^4.4.1",
         "ts-jest": "^28.0.5",
-        "typescript": "^4.9.3"
+        "typescript": "^4.9.5"
     },
     "peerDependencies": {
         "ra-core": "^4.1.0"
+    },
+    "dependencies": {
+        "qs": "^6.11.1"
     }
 }

package/src/index.ts

@@ -1,4 +1,16 @@
-import { fetchUtils, DataProvider } from 'ra-core';
+import {
+    fetchUtils,
+    DataProvider,
+    GetListParams,
+    GetOneParams,
+    GetManyParams,
+    GetManyReferenceParams,
+    UpdateParams,
+    UpdateManyParams,
+    CreateParams,
+    DeleteParams,
+    DeleteManyParams,
+} from 'ra-core';
 import {
     PrimaryKey,
     PostgRestOperator,
@@ -12,6 +24,8 @@ import {
     decodeId,
     isCompoundKey,
 } from './urlBuilder';
+import qs from 'qs';
+
 /**
  * Maps react-admin queries to a postgrest REST API
  *
@@ -35,7 +49,7 @@ import {
  *
  * import * as React from 'react';
  * import { Admin, Resource } from 'react-admin';
- * import postgrestRestProvider from '@promitheus/ra-data-postgrest';
+ * import postgrestRestProvider from '@raphiniert/ra-data-postgrest';
  *
  * import { PostList } from './posts';
  *
@@ -56,30 +70,38 @@ export default (
     defaultListOp: PostgRestOperator = 'eq',
     primaryKeys: Map<string, PrimaryKey> = defaultPrimaryKeys
 ): DataProvider => ({
-    getList: (resource, params) => {
+    getList: (resource, params: Partial<GetListParams> = {}) => {
         const primaryKey = getPrimaryKey(resource, primaryKeys);
 
         const { page, perPage } = params.pagination;
-        const { field, order } = params.sort;
-        const parsedFilter = parseFilters(params.filter, defaultListOp);
+        const { field, order } = params.sort || {};
+        const { filter, select } = parseFilters(params, defaultListOp);
 
-        const query = {
-            order: getOrderBy(field, order, primaryKey),
+        let query = {
             offset: String((page - 1) * perPage),
             limit: String(perPage),
             // append filters
-            ...parsedFilter,
+            ...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}?${new URLSearchParams(query)}`;
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
 
         return httpClient(url, options).then(({ headers, json }) => {
             if (!headers.has('content-range')) {
@@ -99,66 +121,75 @@ export default (
         });
     },
 
-    getOne: (resource, params) => {
-        const id = params.id;
+    getOne: (resource, params: Partial<GetOneParams> = {}) => {
+        const { id, meta } = params;
         const primaryKey = getPrimaryKey(resource, primaryKeys);
 
-        const query = getQuery(primaryKey, id, resource);
+        const query = getQuery(primaryKey, id, resource, meta);
 
-        const url = `${apiUrl}/${resource}?${query}`;
+        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) => {
+    getMany: (resource, params: Partial<GetManyParams> = {}) => {
         const ids = params.ids;
         const primaryKey = getPrimaryKey(resource, primaryKeys);
 
-        const query = getQuery(primaryKey, ids, resource);
-
-        const url = `${apiUrl}/${resource}?${query}`;
+        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) => {
+    getManyReference: (
+        resource,
+        params: Partial<GetManyReferenceParams> = {}
+    ) => {
         const { page, perPage } = params.pagination;
         const { field, order } = params.sort;
-        const parsedFilter = parseFilters(params.filter, defaultListOp);
+
+        const { filter, select } = parseFilters(params, defaultListOp);
         const primaryKey = getPrimaryKey(resource, primaryKeys);
 
-        const query = params.target
+        let query = params.target
             ? {
                   [params.target]: `eq.${params.id}`,
                   order: getOrderBy(field, order, primaryKey),
                   offset: String((page - 1) * perPage),
                   limit: String(perPage),
-                  ...parsedFilter,
+                  ...filter,
               }
             : {
                   order: getOrderBy(field, order, primaryKey),
                   offset: String((page - 1) * perPage),
                   limit: String(perPage),
-                  ...parsedFilter,
+                  ...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}?${new URLSearchParams(query)}`;
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
 
         return httpClient(url, options).then(({ headers, json }) => {
             if (!headers.has('content-range')) {
@@ -178,15 +209,15 @@ export default (
         });
     },
 
-    update: (resource, params) => {
-        const { id, data } = params;
+    update: (resource, params: Partial<UpdateParams> = {}) => {
+        const { id, data, meta } = params;
         const primaryKey = getPrimaryKey(resource, primaryKeys);
 
-        const query = getQuery(primaryKey, id, resource);
+        const query = getQuery(primaryKey, id, resource, meta);
 
         const primaryKeyData = getKeyData(primaryKey, data);
 
-        const url = `${apiUrl}/${resource}?${query}`;
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
 
         const body = JSON.stringify({
             ...data,
@@ -199,12 +230,13 @@ export default (
                 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) => {
+    updateMany: (resource, params: Partial<UpdateManyParams> = {}) => {
         const ids = params.ids;
         const primaryKey = getPrimaryKey(resource, primaryKeys);
 
@@ -236,6 +268,7 @@ export default (
             headers: new Headers({
                 Prefer: 'return=representation',
                 'Content-Type': 'application/json',
+                ...(params.meta?.headers || {}),
             }),
             body,
         }).then(({ json }) => ({
@@ -243,9 +276,8 @@ export default (
         }));
     },
 
-    create: (resource, params) => {
+    create: (resource, params: Partial<CreateParams> = {}) => {
         const primaryKey = getPrimaryKey(resource, primaryKeys);
-
         const url = `${apiUrl}/${resource}`;
 
         return httpClient(url, {
@@ -254,23 +286,24 @@ export default (
                 Accept: 'application/vnd.pgrst.object+json',
                 Prefer: 'return=representation',
                 'Content-Type': 'application/json',
+                ...(params.meta?.headers || {}),
             }),
             body: JSON.stringify(params.data),
         }).then(({ json }) => ({
             data: {
-                ...params.data,
+                ...json,
                 id: encodeId(json, primaryKey),
             },
         }));
     },
 
-    delete: (resource, params) => {
-        const id = params.id;
+    delete: (resource, params: Partial<DeleteParams> = {}) => {
+        const { id, meta } = params;
         const primaryKey = getPrimaryKey(resource, primaryKeys);
 
-        const query = getQuery(primaryKey, id, resource);
+        const query = getQuery(primaryKey, id, resource, meta);
 
-        const url = `${apiUrl}/${resource}?${query}`;
+        const url = `${apiUrl}/${resource}?${qs.stringify(query)}`;
 
         return httpClient(url, {
             method: 'DELETE',
@@ -278,23 +311,25 @@ export default (
                 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) => {
-        const ids = params.ids;
+    deleteMany: (resource, params: Partial<DeleteManyParams> = {}) => {
+        const { ids, meta } = params;
         const primaryKey = getPrimaryKey(resource, primaryKeys);
 
-        const query = getQuery(primaryKey, ids, resource);
+        const query = getQuery(primaryKey, ids, resource, meta);
 
-        const url = `${apiUrl}/${resource}?${query}`;
+        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

@@ -44,13 +44,21 @@ const postgrestOperators = [
     'and',
 ] as const;
 
-export type PostgRestOperator = typeof postgrestOperators[number];
+type ParsedFiltersResult = {
+    filter: any;
+    select: any;
+};
+
+export type PostgRestOperator = (typeof postgrestOperators)[number];
 
 export const parseFilters = (
-    filter: Record<string, any>,
+    params: any,
     defaultListOp: PostgRestOperator
-) => {
-    let result = {};
+): 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
 
@@ -76,21 +84,30 @@ export const parseFilters = (
                 ? `${value}`
                 : `${operation}.${value}`;
 
-            if (result[splitKey[0]] === undefined) {
+            if (result.filter[splitKey[0]] === undefined) {
                 // first operator for the key, we add it to the dict
-                result[splitKey[0]] = op;
+                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?.columns) {
+        result.select = Array.isArray(meta.columns)
+            ? meta.columns.join(',')
+            : meta.columns;
+    }
+
     return result;
 };
 
@@ -140,8 +157,10 @@ export const isCompoundKey = (primaryKey: PrimaryKey): Boolean => {
 export const getQuery = (
     primaryKey: PrimaryKey,
     ids: Identifier | Array<Identifier>,
-    resource: string
-): string => {
+    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/')) {
@@ -153,17 +172,18 @@ export const getQuery = (
         }
 
         if (isCompoundKey(primaryKey)) {
-            // TODO: Should be URL encoded
-            return `or=(${ids.map(id => {
-                const primaryKeyParams = decodeId(id, primaryKey);
-                return `and(${primaryKey
-                    .map((key, i) => `${key}.eq.${primaryKeyParams[i]}`)
-                    .join(',')})`;
-            })})`;
+            result = {
+                or: `(${ids.map(id => {
+                    const primaryKeyParams = decodeId(id, primaryKey);
+                    return `and(${primaryKey
+                        .map((key, i) => `${key}.eq.${primaryKeyParams[i]}`)
+                        .join(',')})`;
+                })})`,
+            };
         } else {
-            return new URLSearchParams({
+            result = {
                 [primaryKey[0]]: `in.(${ids.join(',')})`,
-            }).toString();
+            };
         }
     } else {
         // if ids is one Identifier
@@ -171,27 +191,34 @@ export const getQuery = (
         const primaryKeyParams = decodeId(id, primaryKey);
 
         if (isCompoundKey(primaryKey)) {
-            if (resource.startsWith('rpc/'))
-                // TODO: Should be URL encoded
-                return `${primaryKey
-                    .map(
-                        (key: string, i: any) => `${key}=${primaryKeyParams[i]}`
-                    )
-                    .join('&')}`;
-            // TODO: Should be URL encoded
-            else
-                return `and=(${primaryKey
-                    .map(
+            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]}`
-                    )
-                    .join(',')})`;
+                    )})`,
+                };
+            }
         } else {
-            return new URLSearchParams([
-                [primaryKey[0], `eq.${id}`],
-            ]).toString();
+            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 => {