ezekiel-cli 5.8.2

package/gui/v2/src/hooks/filters.js

@@ -0,0 +1,30 @@
+import { useContext } from "react";
+import { FiltersContext } from "@/context/filters";
+
+export const useFilters = () => {
+    const { filterAttribute, dispatch } = useContext(FiltersContext);
+
+    const setFilterName = (value) => {
+        dispatch({ type: "SET_NAME", name: value });
+    };
+
+    const setFilterBy = (value) => {
+        dispatch({ type: "SET_FILTER_BY", filterBy: value });
+    };
+
+    const setFilterValue = (value) => {
+        dispatch({ type: "SET_VALUE", value: value });
+    };
+
+    const setFilterAttribute = (value) => {
+        dispatch({ type: "SET_ATTRIBUTE_TYPE", attributeType: value });
+    }
+
+    return {
+        filterAttribute,
+        setFilterName,
+        setFilterBy,
+        setFilterAttribute,
+        setFilterValue,
+    }
+};

package/gui/v2/src/hooks/menu.js

@@ -0,0 +1,19 @@
+import { useContext } from "react";
+import { MenuContext } from "@/context/menu";
+
+export const useMenu = () => {
+    const { menus, menuDispatch } = useContext(MenuContext);
+    const expandDescription = (title) => {
+        menuDispatch({ type: "EXPAND", title });
+    };
+
+    const pinMenu = (title) => {
+        menuDispatch({ type: "PIN", title });
+    };
+
+    return {
+        menus,
+        expandDescription,
+        pinMenu,
+    };
+};

package/gui/v2/src/hooks/query.js

@@ -0,0 +1,10 @@
+import { buildQuery } from '@/reducers/query';
+import { runGraphQL } from '@/services/GraphiQLService';
+
+export const useQuery = () => {
+  const executeQuery = async (attributes) => {
+    const payload = buildQuery(attributes);
+    return await runGraphQL(payload);
+  };
+  return { executeQuery };
+};

package/gui/v2/src/hooks/queryParams.js

@@ -0,0 +1,20 @@
+import { useSearchParams } from 'next/navigation';
+import { useCallback } from 'react';
+export const useQueryParams = () => {
+  const searchParams = useSearchParams();
+
+  const createQueryString = useCallback(
+    (name, value) => {
+      const params = new URLSearchParams(searchParams);
+      params.set(name, value);
+
+      return params.toString();
+    },
+    [searchParams]
+  );
+
+  return {
+    searchParams,
+    createQueryString,
+  }
+};

package/gui/v2/src/hooks/recordQuery.js

@@ -0,0 +1,109 @@
+import { OPERATION_TYPES } from "@/constants/records";
+export const useRecordQuery = () => {
+    const getFilterValue = (
+        operation,
+        value,
+        minFilter,
+        minFilterValue,
+        maxFilter,
+        maxFilterValue
+    ) => {
+        if (OPERATION_TYPES.string.includes(operation)) {
+            return `"${value}"`;
+        } else if (OPERATION_TYPES.range.includes(operation)) {
+            return `{ ${minFilter}: "${minFilterValue}", ${maxFilter}: "${maxFilterValue}" }`;
+        } else {
+            return value;
+        }
+    };
+
+    const buildFilterQueryString = (filters) => {
+        return filters
+            .filter((filter) => filter.name !== "id" && filter.value)
+            .map(
+                ({
+                    name,
+                    operation,
+                    value,
+                    minFilter,
+                    minFilterValue,
+                    maxFilter,
+                    maxFilterValue,
+                }) => {
+                    const parsedValue = getFilterValue(
+                        operation,
+                        value,
+                        minFilter,
+                        minFilterValue,
+                        maxFilter,
+                        maxFilterValue
+                    );
+                    return `{
+                name: "${name}",
+                ${operation}: ${parsedValue}
+            }`;
+                }
+            )
+            .join("");
+    };
+
+    const buildQuery = (args) => {
+        const {
+            table,
+            sort,
+            deleted,
+            filters,
+        } = args;
+        console.log(args)
+        const tableFilter = table ? `table_id: { value: ${table} }` : "";
+        const oper = filters?.attributes?.find(
+            (attribute) => attribute.name === "id" && attribute.value
+        )?.operation
+        console.log(oper)
+        const idFilter = oper
+            ? `id: { ${
+                  filters?.attributes?.find((attribute) => attribute.name === "id")
+                      .operation
+              }: ${
+                  filters?.attributes?.find((attribute) => attribute.name === "id")
+                      .value
+              } }`
+            : "";
+        const sortKey =
+            sort && ["id", "created_at", "updated_at"].includes(sort.by)
+                ? sort.by
+                : "properties";
+        const sortValue = sort
+            ? `${sortKey}: { order: ${sort.order} }`
+            : "created_at: { order: DESC }";
+        const deletedFilter = deleted ? `deleted_at: { exists: true }` : "";
+        const filtersQueryString = filters?.attributes?.length
+            ? buildFilterQueryString(filters?.attributes)
+            : "";
+
+        const page = args.filters?.page || 1;
+        return `
+        query {
+            records(
+                page: ${page},
+                per_page: 20,
+                
+                
+            ) {
+                current_page
+                total_pages
+                results {
+                    id
+                    created_at
+                    updated_at
+                    deleted_at
+                    properties
+                }
+            }
+        }`;
+    };
+
+    return {
+        buildQuery,
+    };
+};

package/gui/v2/src/hooks/theme.js

@@ -0,0 +1,6 @@
+import { useContext } from "react";
+import { ThemeContext } from "@/context/theme";
+
+export const useTheme = () => {
+    return useContext(ThemeContext);
+};

package/gui/v2/src/hooks/users.js

@@ -0,0 +1,63 @@
+import { useReducer, useState, useEffect } from 'react';
+import { buildQuery, defaultQueryAttributes, queryReducer } from '@/reducers/query';
+import { runGraphQL } from '@/services/GraphiQLService';
+
+export const useUsers = () => {
+  const defaultUserQueryAttributes = {
+    ...defaultQueryAttributes,
+    func: 'users',
+    per_page: 15,
+    filter: {},
+    response: {
+      root: ['current_page', 'has_next_page', 'has_previous_page', 'per_page', 'total_entries', 'total_pages'],
+      results: [
+        'id',
+        'external_id',
+        'jwt_token',
+        'email',
+        'created_at',
+        'name',
+        'first_name',
+        'last_name',
+        'slug',
+        'language',
+      ],
+    },
+  };
+  const [state, dispatch] = useReducer(queryReducer, defaultUserQueryAttributes);
+  const [data, setData] = useState({});
+
+  const fetchData = async (args) => {
+    try {
+      const payload = buildQuery(args);
+      const data = await runGraphQL(payload);
+      setData(data);
+    } catch (error) {
+      // Handle error
+    }
+  };
+
+  useEffect(() => {
+    fetchData(state);
+  }, []);
+
+  const filterBy = (key, value) => {
+    const updatedFilter = { ...state.filter, [key]: { value } };
+    paginate(1, state.per_page);
+    dispatch({ type: 'SET_FILTER', filter: updatedFilter });
+    fetchData(state);
+  };
+
+  const paginate = (page, pageSize) => {
+    dispatch({ type: 'SET_PAGE', page });
+    dispatch({ type: 'SET_PER_PAGE', per_page: pageSize });
+    fetchData(state);
+  };
+
+  return {
+    queryAttributes: state,
+    filterBy,
+    data,
+    paginate,
+  };
+};

package/gui/v2/src/reducers/filter.js

@@ -0,0 +1,28 @@
+
+export const defaultFilterAttribute = {
+    name: "id",
+    attributeType: "id",
+    filterBy: "id",
+    value: "",
+    sort: {
+        orderBy: "id",
+        order: "desc",
+    },
+};
+
+export const filterReducer = (state, action) => {
+    switch (action.type) {
+        case "SET_NAME":
+            return { ...state, name: action.name, value: "" };
+        case "SET_ATTRIBUTE_TYPE":
+            return { ...state, attributeType: action.attributeType, value: "" };
+        case "SET_FILTER_BY":
+            return { ...state, filterBy: action.filterBy, value: "" };
+        case "SET_VALUE":
+            return { ...state, value: action.value };
+        case "SET_SORT":
+            return { ...state, sort: action.sort };
+        default:
+            return state;
+    }
+};

package/gui/v2/src/reducers/menu.js

@@ -0,0 +1,125 @@
+export const initialMenu = [
+    {
+        title: "Databases",
+        icon: "database",
+        path: "/database",
+        descriptions: [
+            "Inspect tables and records",
+            "Create, edit or delete records",
+            "Filter and find any record",
+        ],
+        showDescription: false,
+        pin: true,
+        section: 1
+    },
+    {
+        title: "Users",
+        icon: "users",
+        path: "/users",
+        descriptions: [
+            "Inspect registered users and their personal data",
+        ],
+        showDescription: false,
+        pin: true,
+        section: 1
+    },
+    {
+        title: "Logs",
+        icon: "logs",
+        path: "/logs",
+        descriptions: [
+            "View system logs",
+            "Inspect logs you've outputted yourself",
+            "Debug Liquid or GraphQL errors",
+        ],
+        showDescription: false,
+        pin: true,
+        section: 1
+    },
+    {
+        title: "Background Jobs",
+        icon: "bg-job",
+        path: "/background-job",
+        descriptions: [
+            "List scheduled background jobs",
+            "Debug background jobs that failed to run",
+        ],
+        showDescription: false,
+        pin: true,
+        section: 1
+    },
+    {
+        title: "Constants",
+        icon: "constants",
+        path: "/constants",
+        descriptions: [
+            "Check all constants in one place",
+            "Create new constants",
+            "Edit or delete existing ones",
+        ],
+        showDescription: false,
+        pin: true,
+        section: 1
+    },
+    {
+        title: "Liquid Evaluator",
+        icon: "liquid",
+        path: "/liquid",
+        descriptions: [
+            "Run Liquid code against your instance",
+            "Test Liquid logic",
+            "Quickly prototype your ideas",
+        ],
+        showDescription: false,
+        pin: true,
+        section: 1
+    },
+    {
+        title: "GraphQL",
+        icon: "graphql",
+        path: "/graphql",
+        descriptions: [
+            "Run GraphQL against your instance",
+            "Explore documentation",
+            "Quickly prototype your queries and mutations",
+        ],
+        showDescription: false,
+        pin: true,
+        section: 1
+    },
+    {
+        title: "Support",
+        icon: "support",
+        path: "/support",
+        descriptions: [
+            "Contact Insites Support"
+        ],
+        showDescription: false,
+        pin: true,
+        section: 2
+    },
+];
+
+export const menuReducer = (state, action) => {
+    switch (action.type) {
+        case "PIN":
+            return state.map((menu) => {
+                if (menu.title === action.title) {
+                    return { ...menu, pin: !menu.pin };
+                } else {
+                    return menu;
+                }
+            });
+
+        case "EXPAND":
+            return state.map((menu) => {
+                if (menu.title === action.title) {
+                    return { ...menu, showDescription: !menu.showDescription };
+                } else {
+                    return menu;
+                }
+            });
+        default:
+            return state;
+    }
+};

package/gui/v2/src/reducers/query.js

@@ -0,0 +1,143 @@
+export const defaultQueryAttributes = {
+  func: 'records',
+  page: 1,
+  per_page: 20,
+  filter: {
+    id: {},
+    table: {},
+    properties: [],
+  },
+  sort: {},
+  response: {
+    root: [], // ['current_page', 'has_next_page', 'has_previous_page', 'per_page', 'total_entries', 'total_pages'],
+    results: [], // ['id', 'created_at', 'updated_at', 'deleted_at', 'properties'],
+  },
+};
+
+export const queryReducer = (state, action) => {
+  switch (action.type) {
+    case 'SET_FUNC':
+      return { ...state, func: action.func };
+    case 'SET_PAGE':
+      return { ...state, page: action.page };
+    case 'SET_PER_PAGE':
+      return { ...state, per_page: action.per_page };
+    case 'SET_FILTER':
+      return { ...state, filter: action.filter };
+
+    case 'ADD_FILTER_PROPERTY':
+      return { ...state, filter: { ...state.filter, properties: [...state.filter.properties, action.property] } };
+    case 'REMOVE_FILTER_PROPERTY':
+      return {
+        ...state,
+        filter: {
+          ...state.filter,
+          properties: state.filter.properties.filter((property) => property.name !== action.name),
+        },
+      };
+    case 'EDIT_FILTER_PROPERTY':
+      return {
+        ...state,
+        filter: {
+          ...state.filter,
+          properties: state.filter.properties.map((property) =>
+            property.name === action.property.name ? action.property : property
+          ),
+        },
+      };
+    case 'SET_RESPONSE_ROOT':
+      return { ...state, response: { ...state.response, root: action.root } };
+    case 'SET_RESPONSE_RESULTS':
+      return { ...state, response: { ...state.response, results: action.results } };
+
+    case 'SET_SORT':
+      return { ...state, sort: action.sort };
+    default:
+      return state;
+  }
+};
+
+const hasValue = (value) => {
+  if (value === null || value === undefined) {
+    return false;
+  }
+
+  if (typeof value === 'boolean' || typeof value === 'number' || (typeof value === 'string' && value.trim() !== '')) {
+    return true;
+  }
+
+  if (Array.isArray(value) && value.length > 0) {
+    return true;
+  }
+
+  if (typeof value === 'object' && Object.keys(value).length > 0) {
+    return true;
+  }
+
+  return false;
+};
+
+export const buildQuery = (attributes = defaultQueryAttributes) => {
+  const { func, page, per_page, filter, sort, response } = attributes;
+  const filterString = hasValue(filter) ? `filter: ${JSON.stringify(filter).replace(/"(\w+)":/g, '$1:')}` : '';
+  const sortString = hasValue(sort) ? `sort: { ${sort.by}: { order: ${sort.order} } }` : '';
+  const responseResults = hasValue(response.results) ? `results { ${response.results.join('\n')} }` : '';
+
+  const queryPayload = `
+    query {
+        ${func}(
+            page: ${page}
+            per_page: ${per_page}
+            ${filterString}
+            ${sortString}
+        ){
+            ${response.root.join('\n')}
+            ${responseResults}
+        }
+    }
+  `;
+  return { query: queryPayload };
+};
+
+const createArgsString = (args) =>
+  Object.entries(args).reduce((statement, [key, value]) => {
+    const formattedValue = (() => {
+      const seen = new Set(); // Declaring the 'seen' set
+      
+      return JSON.stringify(
+        value,
+        // Replacer function to handle circular references
+        (_, val) => {
+          if (typeof val === 'object' && val !== null) {
+            if (seen.has(val)) {
+              return;
+            }
+            seen.add(val);
+          }
+          return val;
+        }
+      ).replace(/"(\w+)":/g, '$1:');
+    })();
+    
+    const keyPair = `${key}: ${formattedValue}`;
+
+    return `${statement}${keyPair}\n`;
+  }, '');
+
+export const buildMutationQuery = (attributes) => {
+  const { func, args, response } = attributes;
+
+  const argsString = createArgsString(args);
+  const responseResults = hasValue(response.results) ? `results { ${response.results.join('\n')} }` : '';
+  const mutationPayload = `
+    mutation {
+      ${func} (
+        ${argsString}
+      ) {
+        ${response.root.join('\n')}
+        ${responseResults}
+      }
+    }
+  `;
+  return { query: mutationPayload };
+};

package/gui/v2/src/services/ConfigService.js

@@ -0,0 +1,7 @@
+import { processRequestAndResponse } from '@/services/CoreService.js';
+const apiURL = process.env.NEXT_PUBLIC_API_URL || "";
+
+export const getConfigs = async (args = {}, errorHandler = (data) => data) => {
+  const { data: response } = await processRequestAndResponse(`${apiURL}/info`, 'get', args, { errorHandler });
+  return response;
+};

package/gui/v2/src/services/CoreService.js

@@ -0,0 +1,68 @@
+'use client';
+const apiHeader = (element = '') => {
+  return {
+    'X-Requested-With': 'XMLHttpRequest',
+    Accept: 'application/json',
+    'Content-Type': 'application/json',
+    'X-CSRF-Token': element,
+  };
+};
+const insHeader = apiHeader();
+
+export async function processRequestAndResponse(url, method = 'GET', data = {}, options = {}) {
+  const headers = options.headers || insHeader;
+  const errorHandler = options.errorHandler || (() => {});
+  return await processRequest(url, method, data, headers)
+    .then((response) => {
+      if (
+        response &&
+        response.request &&
+        response.request.responseURL &&
+        response.request.responseURL.indexOf('/401?return_to=') !== -1
+      ) {
+        location.assign(response.request.responseURL);
+      } else {
+        if (response.data && response.data.errors) {
+          if (typeof response.data.errors === 'object' && !Object.keys(response.data.errors).length) {
+            return { state: true, data: response.data };
+          } else {
+            errorHandler(response.data.errors);
+            return {
+              state: false,
+              data: response.data,
+              api_error: true,
+            };
+          }
+        }
+        return { state: true, data: response };
+      }
+    })
+    .catch((error) => {
+      errorHandler(error);
+      const data = error.response && error.response.data ? error.response.data : error;
+      return { state: false, data: data };
+    });
+}
+
+export async function processRequest(endpoint, method = 'GET', data = {}, headers = insHeader) {
+  let baseURL = '';
+
+  if (!endpoint.startsWith('http')) {
+    if (window) {
+      baseURL = window.location.origin;
+    }
+  }
+  const url = `${baseURL}${endpoint}`;
+
+  const requestOptions = {
+    method,
+    headers: new Headers(headers),
+  };
+
+  if (method.toUpperCase() !== 'GET') {
+    requestOptions.body = data ? JSON.stringify(data) : undefined;
+  }
+
+  const response = await fetch(url, requestOptions);
+  return await response.json();
+}

package/gui/v2/src/services/GraphiQLService.js

@@ -0,0 +1,14 @@
+import { processRequestAndResponse } from '@/services/CoreService.js';
+const apiURL = process.env.NEXT_PUBLIC_API_URL || '';
+
+export async function runGraphQL(payload, errorHandler = (data) => data) {
+  const url = `${apiURL}/api/graphql`;
+  const { data: response } = await processRequestAndResponse(url, 'post', payload, {
+    errorHandler,
+  });
+
+  const { data, errors } = response;
+  if (errors) throw errors;
+
+  return data;
+}

package/gui/v2/src/services/LiquidService.js

@@ -0,0 +1,7 @@
+import { processRequestAndResponse } from '@/services/CoreService.js';
+const apiURL = process.env.NEXT_PUBLIC_API_URL || "";
+
+export const parseLiquid = async (args, errorHandler = (data) => data) => {
+  const { data: response } = await processRequestAndResponse(`${apiURL}/api/liquid`, 'post', args, { errorHandler });
+  return response;
+};

package/gui/v2/src/services/LogService.js

@@ -0,0 +1,7 @@
+import { processRequestAndResponse } from '@/services/CoreService.js';
+const apiURL = process.env.NEXT_PUBLIC_API_URL || "";
+
+export const getLogs = async (lastId = null, errorHandler = (data) => data) => {
+  const { data: response } = await processRequestAndResponse(`${apiURL}/api/logs?lastId=${lastId}`, 'get', { errorHandler });
+  return response;
+};