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(),
};

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, sort }) => {
      const sortAttribute = sort.field === "id" ? "eid" : sort.field;
      const attributesNames = ["eid", ...Object.keys(schema.etypes[resource])];
      const selection: string[] = [];
      const restrictions: string[] = [];
      let sortvariable = null;
      attributesNames.forEach((key, idx) => {
        const variable = `X${idx}`;
        selection.push(variable);
        restrictions.push(`X ${key} ${variable}`);
        if (key === sortAttribute) {
          sortvariable = variable;
        }
      });
      const total = await rqlClient
        .queryRows(`Any Count(${selection[0]}) WHERE ${restrictions.join(",")}`)
        .then((rows) => rows[0][0]);
      return rqlClient
        .queryRows(
          `Any ${selection.join(", ")}  ORDERBY ${sortvariable} ${
            sort.order
          } 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) => {
      // FIXME  Retrieve object relation
      // Getting attributes
      const attributesNames = [...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(",")}, X eid ${
          params.id
        }`
      );
      const row = result[0];
      const entity = row.reduce(
        (agg, attributeValue, idx) => ({
          [attributesNames[idx]]: attributeValue,
          ...agg,
        }),
        { eid: params.id, id: params.id }
      );

      // Getting relations
      const subjectRelations = Object.fromEntries(
        Object.entries(schema.relationships).filter(
          ([_relationName, definition]: [string, S["relationships"][string]]) =>
            definition.subject === resource
        )
      );
      for (const relationName in subjectRelations) {
        const definition: S["relationships"][string] =
          subjectRelations[relationName];

        const result = await rqlClient.queryRows(
          `Any TARGET Where TARGET is ${definition.object},X ${relationName} TARGET, X eid ${params.id}`
        );
        if (result.length !== 0) {
          entity[relationName] = result.map((row) => row[0]);
        }
      }
      return { data: entity };
    },
    getMany: async (resource, params) => {
      // FIXME handle several params id and refactor code to use GetOne
      // Getting attributes
      const attributesNames = [...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(",")}, X eid ${
          params.ids[0]
        }`
      );
      const row = result[0];
      const entity = row.reduce(
        (agg, attributeValue, idx) => ({
          [attributesNames[idx]]: attributeValue,
          ...agg,
        }),
        { id: params.ids[0] }
      );

      return { data: [entity] };
    },
    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"),
  };
}