index.ts

import { client } from "@logilab/cwclientlibjs";
import { AuthProvider, DataProvider } from "ra-core";
import { Schema, ETypesNames } from "./Schema";

// import authProvider from './authProvider';
// see https://marmelab.com/react-admin/Authentication.html
export const authProvider: AuthProvider = {
  // authentication
  login: (_params) => Promise.resolve(),
  checkError: (_error) => Promise.resolve(),
  checkAuth: (_params) => Promise.resolve(),
  logout: () => Promise.resolve(),
  getIdentity: () => Promise.resolve({ id: 0 }),
  // authorization
  getPermissions: (_params) => Promise.resolve(),
};

interface Entity {
  eid: string;
}

export function createDataProvider<S extends Schema>(
  endpoint: string,
  schema: S
): DataProvider {
  const httpClient = new client.CwSimpleHttpClient(endpoint, true);
  const rqlClient = new client.CwRqlClient(httpClient);
  return {
    getList: async (resource: ETypesNames<S>, { pagination }) => {
      const attributesNames = ["eid", ...Object.keys(schema.etypes[resource])];
      const selection: string[] = [];
      const restrictions: string[] = [];
      attributesNames.forEach((key, idx) => {
        const variable = `X${idx}`;
        selection.push(variable);
        restrictions.push(`X ${key} ${variable}`);
      });
      const total = await rqlClient
        .queryRows(`Any Count(${selection[0]}) WHERE ${restrictions.join(",")}`)
        .then((rows) => rows[0][0]);
      return rqlClient
        .queryRows(
          `Any ${selection.join(", ")} LIMIT ${pagination.perPage} OFFSET ${
            pagination.page * pagination.perPage
          } WHERE ${restrictions.join(", ")}`,
          {}
        )
        .then((rows) => {
          return {
            data: rows.map((row) =>
              row.reduce(
                (agg, attributeValue, idx) => ({
                  [attributesNames[idx]]: attributeValue,
                  ...agg,
                }),
                { id: row[0] }
              )
            ),
            total,
          };
        });
    },
    getOne: async (resource: ETypesNames<S>, _params) => {
      const attributesNames = ["eid", ...Object.keys(schema.etypes[resource])];
      const selection: string[] = [];
      const restrictions: string[] = [];
      attributesNames.forEach((key, idx) => {
        const variable = `X${idx}`;
        selection.push(variable);
        restrictions.push(`X ${key} ${variable}`);
      });
      const result = await rqlClient.queryRows(
        `Any ${selection.join(",")} Where ${restrictions.join(",")}`
      );
      const row = result[0];
      return {
        data: row.reduce(
          (agg, attributeValue, idx) => ({
            [attributesNames[idx]]: attributeValue,
            ...agg,
          }),
          { id: row[0] }
        ),
      };
    },
    getMany: (_resource, _params) => Promise.reject("Not implemented"),
    getManyReference: (_resource, _params) => Promise.reject("Not implemented"),
    update: (_resource, _params) => Promise.reject("Not implemented"),
    updateMany: (_resource, _params) => Promise.reject("Not implemented"),
    create: (_resource, _params) => Promise.reject("Not implemented"),
    delete: (_resource, _params) => Promise.reject("Not implemented"),
    deleteMany: (_resource, _params) => Promise.reject("Not implemented"),
  };
}