@trackunit/filters-graphql-hook 0.0.1

package/README.md

@@ -0,0 +1,22 @@
+> **⚠️ Beta**
+>
+> This is a beta version and subject to change without notice.
+
+# Trackunit Filters graphql hooks Components 
+The `@trackunit/filters-graphql-hook` package is the home of our graphql hooks, that can take input of filterBar values and convert to gql types.
+
+This library is exposed publicly for use in the the Trackunit [Iris App SDK](https://www.npmjs.com/package/@trackunit/iris-app).  
+
+To browse all available components visit our [Public Storybook](https://developers.trackunit.com/page/ui-components).
+
+For more info and a full guide on Iris App SDK Development, please visit our [Developer Hub](https://developers.trackunit.com/).
+
+## Development
+At this point this library is only developed by Trackunit Employees.
+For development related information see the [development readme](https://github.com/Trackunit/manager/blob/master/libs/react/components/DEVELOPMENT.md).
+
+## Trackunit
+This package was developed by Trackunit ApS.
+Trackunit is the leading SaaS-based IoT solution for the construction industry, offering an ecosystem of hardware, fleet management software & telematics.
+
+![The Trackunit logo](https://trackunit.com/wp-content/uploads/2022/03/top-logo.svg)

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,400 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+require('react/jsx-runtime');
+var i18nLibraryTranslation = require('@trackunit/i18n-library-translation');
+var filtersFilterBar = require('@trackunit/filters-filter-bar');
+var sharedUtils = require('@trackunit/shared-utils');
+var reactCoreHooks = require('@trackunit/react-core-hooks');
+var react = require('react');
+
+var defaultTranslations = {
+	
+};
+
+/** The translation namespace for this library */
+const namespace = "filters.graphql-hook";
+/**
+ * The TranslationResource for this Library.
+ * Holds lazy loaded imports for all languages supported by the library.
+ *
+ * This is used to register the translations for this library before initializing i18next.
+ */
+const translations = {
+    ns: namespace,
+    default: defaultTranslations,
+    languages: {
+        de: () => Promise.resolve().then(function () { return require('./translation.cjs.js'); }),
+        da: () => Promise.resolve().then(function () { return require('./translation.cjs2.js'); }),
+        cs: () => Promise.resolve().then(function () { return require('./translation.cjs3.js'); }),
+        nl: () => Promise.resolve().then(function () { return require('./translation.cjs4.js'); }),
+        fr: () => Promise.resolve().then(function () { return require('./translation.cjs5.js'); }),
+        fi: () => Promise.resolve().then(function () { return require('./translation.cjs6.js'); }),
+        hu: () => Promise.resolve().then(function () { return require('./translation.cjs7.js'); }),
+        it: () => Promise.resolve().then(function () { return require('./translation.cjs8.js'); }),
+        nb: () => Promise.resolve().then(function () { return require('./translation.cjs9.js'); }),
+        pl: () => Promise.resolve().then(function () { return require('./translation.cjs10.js'); }),
+        pt: () => Promise.resolve().then(function () { return require('./translation.cjs11.js'); }),
+        ru: () => Promise.resolve().then(function () { return require('./translation.cjs12.js'); }),
+        ro: () => Promise.resolve().then(function () { return require('./translation.cjs13.js'); }),
+        es: () => Promise.resolve().then(function () { return require('./translation.cjs14.js'); }),
+        sv: () => Promise.resolve().then(function () { return require('./translation.cjs15.js'); }),
+        ja: () => Promise.resolve().then(function () { return require('./translation.cjs16.js'); }),
+        th: () => Promise.resolve().then(function () { return require('./translation.cjs17.js'); }),
+    },
+};
+/**
+ * Registers the translations for this library
+ */
+const setupLibraryTranslations = () => {
+    i18nLibraryTranslation.registerTranslations(translations);
+};
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isStringFilterValue = (value) => {
+    return typeof value === "string";
+};
+/**
+ * Fix types for filter values
+ *
+ * @param values - filter values
+ * @param outputTypeRecord - record with output types
+ * @returns {Record | undefined}- fixed filter values
+ */
+const fixTypes = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+values, outputTypeRecord) => {
+    if (!values) {
+        return undefined;
+    }
+    if (Array.isArray(values) && values.length === 0) {
+        return undefined;
+    }
+    if (filtersFilterBar.isStringArrayFilterValue(values)) {
+        const result = values.map(value => {
+            const valuesFromOutput = Object.values(outputTypeRecord);
+            const convertedValue = valuesFromOutput.find(v => value === v);
+            if (!convertedValue) {
+                throw Error(`Unknown value: ${value} expect one of: ${JSON.stringify(Object.values(outputTypeRecord))}`);
+            }
+            // eslint-disable-next-line local-rules/no-typescript-assertion
+            return convertedValue;
+        });
+        return result.filter(sharedUtils.truthy);
+    }
+    if (isStringFilterValue(values)) {
+        const valuesFromOutput = Object.values(outputTypeRecord);
+        const convertedValue = valuesFromOutput.find(v => values === v);
+        if (!convertedValue) {
+            throw Error(`Unknown value: ${values} expect one of: ${JSON.stringify(Object.values(outputTypeRecord))}`);
+        }
+        // eslint-disable-next-line local-rules/no-typescript-assertion
+        return [convertedValue];
+    }
+    throw Error(`Unknown value: ${values} should be a string array`);
+};
+/**
+ * Fix type for filter value
+ *
+ * @param values - filter value
+ * @param outputTypeRecord - record with output types
+ * @returns {Record | null}- fixed filter value
+ */
+const fixType = (values, outputTypeRecord) => {
+    if (!values) {
+        return null;
+    }
+    const convertedValue = outputTypeRecord[values];
+    if (!convertedValue) {
+        throw Error(`Unknown value: ${values} expect one of: ${JSON.stringify(Object.values(outputTypeRecord))}`);
+    }
+    // eslint-disable-next-line local-rules/no-typescript-assertion
+    return convertedValue;
+};
+/**
+ * Check if value is not empty
+ */
+const valuesIfNotEmpty = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+value) => {
+    if (Array.isArray(value)) {
+        return value.length > 0 ? value : undefined;
+    }
+    return value;
+};
+/**
+ *  Check if value is string array
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isStringArrayValue = (value) => {
+    return Array.isArray(value) && value.every(item => typeof item === "string");
+};
+/**
+ * Check if value is string array or undefined
+ */
+const stringArrayOrUndefined = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+value) => {
+    if (isStringArrayValue(value)) {
+        return value.length > 0 ? value : undefined;
+    }
+    return undefined;
+};
+/**
+ * Check if value is ValueName[]
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const isValueName = (value) => {
+    return (Array.isArray(value) &&
+        value.every(item => typeof item === "object" && Object.keys(item).includes("name") && Object.keys(item).includes("value")));
+};
+/**
+ * Check if value is ValueName[] or undefined
+ */
+const valueNameArrayOrUndefined = (
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+input) => {
+    if (isValueName(input) && input.length > 0) {
+        return input.map(item => item.value);
+    }
+    return undefined;
+};
+
+const assetActivityState = {
+    Idling: "IDLING",
+    Stopped: "STOPPED",
+    Unknown: "UNKNOWN",
+    Working: "WORKING",
+};
+const assetCriticalityState = {
+    Critical: "CRITICAL",
+    Low: "LOW",
+    None: "NONE",
+};
+const assetLastSeen = {
+    Last_7Days: "LAST_7_DAYS",
+    Last_24Hours: "LAST_24_HOURS",
+    Last_30Days: "LAST_30_DAYS",
+    LastHour: "LAST_HOUR",
+    OlderThan_30Days: "OLDER_THAN_30_DAYS",
+};
+const assetType = {
+    Attachment: "ATTACHMENT",
+    Equipment: "EQUIPMENT",
+    Gateway: "GATEWAY",
+    Machine: "MACHINE",
+    Other: "OTHER",
+    Tool: "TOOL",
+};
+const rentalStatus = {
+    Available: "Available",
+    InRepair: "InRepair",
+    NotOnContract: "NotOnContract",
+    OffRent: "OffRent",
+    OnRent: "OnRent",
+    Other: "Other",
+    PickupReady: "PickupReady",
+    Reserved: "Reserved",
+    Returned: "Returned",
+    Transfer: "Transfer",
+};
+const servicePlanStatus = {
+    Complete: "COMPLETE",
+    Draft: "DRAFT",
+    FullyConfigured: "FULLY_CONFIGURED",
+    HasPlan: "HAS_PLAN",
+    HasServiceProvider: "HAS_SERVICE_PROVIDER",
+    MissingPlan: "MISSING_PLAN",
+    MissingProvider: "MISSING_PROVIDER",
+    Overdue: "OVERDUE",
+    Planned: "PLANNED",
+    Unknown: "UNKNOWN",
+    Upcoming: "UPCOMING",
+};
+const siteTypeSfs = {
+    Area: "AREA",
+    ClassicPoi: "CLASSIC_POI",
+    ClassicZone: "CLASSIC_ZONE",
+    ConstructionSite: "CONSTRUCTION_SITE",
+    Depot: "DEPOT",
+    NotOnSite: "NOT_ON_SITE",
+    WorkPlace: "WORK_PLACE",
+};
+
+const CustomFieldPrefix$1 = "cf__";
+/**
+ * Converts custom field filters to a format that can be used by the GraphQL API
+ *
+ * @param filters   Custom field filters
+ * @returns {CustomFieldFilter[]}        Custom field filters in a format that can be used by the GraphQL API
+ */
+// eslint-disable-next-line @typescript-eslint/ban-types
+const useCustomFieldFilters = (filters) => {
+    return react.useMemo(() => {
+        const result = [];
+        if (filters) {
+            Object.entries(filters).forEach(([key, value]) => {
+                const customFieldValue = value;
+                if (key.startsWith(CustomFieldPrefix$1)) {
+                    const definitionId = key.replace(CustomFieldPrefix$1, "");
+                    if (filtersFilterBar.isStringArrayFilterValue(customFieldValue) && customFieldValue.length > 0) {
+                        result.push({
+                            definitionId,
+                            stringArrayValue: customFieldValue,
+                        });
+                    }
+                    else if (filtersFilterBar.isMinMaxFilterValue(customFieldValue) && (customFieldValue.min || customFieldValue.max)) {
+                        result.push({
+                            definitionId,
+                            numberRange: {
+                                from: customFieldValue.min,
+                                to: customFieldValue.max,
+                            },
+                        });
+                    }
+                    else if (filtersFilterBar.isDateRangeValue(customFieldValue) && (customFieldValue.from || customFieldValue.to)) {
+                        result.push({
+                            definitionId,
+                            dateRange: {
+                                from: customFieldValue.from,
+                                to: customFieldValue.to,
+                            },
+                        });
+                    }
+                    else if (filtersFilterBar.isBooleanValue(customFieldValue)) {
+                        result.push({
+                            definitionId,
+                            booleanValue: customFieldValue.booleanValue === undefined ? null : customFieldValue.booleanValue,
+                        });
+                    }
+                }
+            });
+        }
+        return result;
+    }, [filters]);
+};
+
+const CustomFieldPrefix = "cf__";
+/**
+ * Converts field filters to a format that can be used by the GraphQL API for AssetFiltersInput
+ *
+ * @param filters  FilterBarValues
+ * @returns {AssetFiltersInput}  Custom field filters in a format that can be used by the GraphQL API
+ */
+const useActiveAssetFilters = (filters) => {
+    const { systemOfMeasurement } = reactCoreHooks.useCurrentUserSystemOfMeasurement();
+    const customFields = useCustomFieldFilters({ filters });
+    // TODO make typesafe checks for all filters
+    const filter = react.useMemo(() => {
+        var _a, _b;
+        if (!filters) {
+            return {};
+        }
+        const followExist = filters.followed === "ALL" ? undefined : true;
+        return {
+            assetIds: stringArrayOrUndefined(filters.assetIds),
+            searchQuery: filters.search === "" || !filters.search ? undefined : filters.search,
+            activities: fixTypes(filters.activity, assetActivityState),
+            boundingBox: filters.boundingBox ? filters.boundingBox : undefined,
+            brands: stringArrayOrUndefined(filters.brands),
+            types: stringArrayOrUndefined(filters.types),
+            criticalities: fixTypes(filters.criticality, assetCriticalityState),
+            productionYears: valueNameArrayOrUndefined(filters.productionYears),
+            followed: filters.followed ? followExist : false,
+            lastSeen: filters.lastSeen === "ALL" || !filters.lastSeen ? undefined : (_a = fixTypes(filters.lastSeen, assetLastSeen)) === null || _a === void 0 ? void 0 : _a[0],
+            models: stringArrayOrUndefined(filters.models),
+            ownerAccountIds: valueNameArrayOrUndefined(filters.ownerAccountIds),
+            assetTypes: fixTypes(filters.assetType, assetType),
+            servicePlanStatuses: fixTypes(filters.serviceStatus, servicePlanStatus),
+            servicePlanAssignments: fixTypes(filters.servicePlanStatus, servicePlanStatus),
+            servicePlanIds: valueNameArrayOrUndefined(filters.servicePlan),
+            serviceProviderIds: valueNameArrayOrUndefined(filters.serviceProvider),
+            //currently we support only 1 filter value to be set so there won't be a second value, soon the partnerId will be transformed to a normal filter and will support an array of strings
+            partnerId: (_b = valueNameArrayOrUndefined(filters.partner)) === null || _b === void 0 ? void 0 : _b[0],
+            groups: valueNameArrayOrUndefined(filters.groups),
+            siteIds: valueNameArrayOrUndefined(filters.siteIds),
+            siteTypes: fixTypes(filters.siteType, siteTypeSfs),
+            rentalCustomerName: stringArrayOrUndefined(filters.rentalCustomerName),
+            rentalStatus: fixTypes(filters.rentalStatus, rentalStatus),
+            customFields: valuesIfNotEmpty(customFields),
+            systemOfMeasurement: systemOfMeasurement,
+        };
+    }, [filters, customFields, systemOfMeasurement]);
+    return filter;
+};
+
+/**
+ * This hook is used to convert the sorting state from the AssetSortingContext to the AssetSortInput used by the GraphQL API
+ */
+const useAssetSortInput = () => {
+    const { sortingState } = reactCoreHooks.useAssetSorting();
+    return react.useMemo(() => convertToAssetSortInput(sortingState), [sortingState]);
+};
+/**
+ * Convert the sorting state from the AssetSortingContext to the AssetSortInput used by the GraphQL API
+ */
+const convertToAssetSortInput = ({ sortBy, order, customFieldDefinitionId }) => {
+    // If any of these fails, it might be because the `AssetSortByProperty` needs to be updated to match the GraphQL enum
+    return {
+        property: sortBy,
+        order,
+        customFieldDefinitionId,
+    };
+};
+
+/**
+ * A hook used to handle asset query filters.
+ * It resets the pagination when filters change.
+ * The assetQueryVariables can be passed directly to any AssetsResolver based query.
+ * The filters are converted to the GraphQL API format.
+ *
+ * @example const { assetQueryVariables } = useAssetQueryFilters({ filters: filterBar.filterBarConfig.values });
+ * const { data: assets } = useMyAssetsQuery({
+ *  variables: assetQueryVariables,
+ * });
+ * @returns {AssetQueryFilters} - assetQueryVariables
+ */
+const useAssetQueryFilters = (props) => {
+    const filters = useActiveAssetFilters(props.filters);
+    const sort = useAssetSortInput();
+    const { systemOfMeasurement } = reactCoreHooks.useCurrentUserSystemOfMeasurement();
+    const assetQueryVariables = react.useMemo(() => ({
+        filters,
+        sort,
+        first: props.first || 50,
+        systemOfMeasurement: systemOfMeasurement,
+        // TODO only load custom fields active filters and visible custom field columns in table
+        // definitionIds:
+        //   filters.customFields && filters.customFields.length > 0
+        //     ? filters.customFields.map(customField => customField.definitionId!)
+        //     : undefined,
+        definitionIds: undefined,
+    }), [filters, props.first, sort, systemOfMeasurement]);
+    return react.useMemo(() => ({
+        assetQueryVariables: assetQueryVariables,
+    }), [assetQueryVariables]);
+};
+
+/*
+ * ----------------------------
+ * | SETUP TRANSLATIONS START |
+ * ----------------------------
+ * This import and function call is needed to register translations for this library.
+ * Do not remove this if this library has translations.
+ */
+setupLibraryTranslations();
+
+exports.CustomFieldPrefix = CustomFieldPrefix;
+exports.convertToAssetSortInput = convertToAssetSortInput;
+exports.fixType = fixType;
+exports.fixTypes = fixTypes;
+exports.isStringArrayValue = isStringArrayValue;
+exports.isValueName = isValueName;
+exports.stringArrayOrUndefined = stringArrayOrUndefined;
+exports.useActiveAssetFilters = useActiveAssetFilters;
+exports.useAssetQueryFilters = useAssetQueryFilters;
+exports.useAssetSortInput = useAssetSortInput;
+exports.useCustomFieldFilters = useCustomFieldFilters;
+exports.valueNameArrayOrUndefined = valueNameArrayOrUndefined;
+exports.valuesIfNotEmpty = valuesIfNotEmpty;