@opengis/gis 0.2.176 → 0.2.178

package/server/routes/registers/functions/getFilterSQLParametrized/getRangeQuery.js

@@ -0,0 +1,353 @@
+/* eslint-disable no-restricted-globals */
+const dateTypeList = [
+  "date",
+  "timestamp",
+  "timestamp without time zone",
+  "timestamp with time zone",
+];
+const numberTypeList = [
+  "float8",
+  "int4",
+  "int8",
+  "numeric",
+  "double precision",
+  "integer",
+  "bigint",
+];
+
+const isValidDate = (dateStr) => {
+  if (!dateStr) {
+    return false;
+  }
+
+  if (["min", "max", "cd", "cw", "cm", "cq", "cy"].includes(dateStr)) {
+    return true;
+  }
+
+  // iso date: 2024-01-01
+  if (dateStr.includes("-")) {
+    return new Date(dateStr).toString() !== "Invalid Date";
+  }
+
+  // locale date: 01.01.2024
+  const [dd, mm, yyyy] = dateStr.split(".");
+  return new Date(`${yyyy}-${mm}-${dd}`).toString() !== "Invalid Date";
+};
+
+const isValidNumber = (numStr) =>
+  ["min", "max"].includes(numStr) ? true : !isNaN(numStr);
+
+function dt(y, m, d) {
+  return new Date(Date.UTC(y, m, d)).toISOString().slice(0, 10);
+}
+
+const dp = {
+  d: new Date().getDate(),
+  w: new Date().getDate() - (new Date().getDay() || 7) + 1,
+  m: new Date().getMonth(),
+  q: parseFloat((new Date().getMonth() / 4).toFixed()) * 3,
+  y: new Date().getFullYear(),
+};
+function formatDateISOString(date) {
+  if (!date?.includes(".")) return date;
+  const [day, month, year] = date.split(".");
+  return `${year}-${month}-${day}`;
+}
+
+function checkValid(
+  value,
+  fieldType,
+  filterType,
+  sql,
+) {
+  const sep =
+    (value.includes(",") ? "," : null) ||
+    (value.includes("_") ? "_" : null) ||
+    (value.includes("-") ? "-" : null);
+
+  // number range w/o valid separator => skip invalid filter
+  if (filterType === "range" && !sep) {
+    return { isvalid: false };
+  }
+
+  // date range, specific options: current day, week, month, year etc.
+  if (["date", "datepicker"].includes(filterType) && value === "cd") {
+    return {
+      min: dt(dp.y, dp.m, dp.d),
+      max: dt(dp.y, dp.m, dp.d),
+      isvalid: true,
+    };
+  }
+
+  if (["date", "datepicker"].includes(filterType) && value === "cw") {
+    return {
+      min: dt(dp.y, dp.m, dp.w),
+      max: dt(dp.y, dp.m, dp.w + 6),
+      isvalid: true,
+    };
+  }
+
+  if (["date", "datepicker"].includes(filterType) && value === "cm") {
+    return {
+      min: dt(dp.y, dp.m, 1),
+      max: dt(dp.y, dp.m + 1, 0),
+      isvalid: true,
+    };
+  }
+
+  if (["date", "datepicker"].includes(filterType) && value === "cq") {
+    return {
+      min: dt(dp.y, dp.q, 1),
+      max: dt(dp.y, dp.q + 3, 0),
+      isvalid: true,
+    };
+  }
+
+  if (["date", "datepicker"].includes(filterType) && value === "cy") {
+    return {
+      min: dt(dp.y, 0, 1),
+      max: dt(dp.y, 11, 31),
+      isvalid: true,
+    };
+  }
+
+  // specific period from now - days, months, years
+  if (
+    ["date", "datepicker"].includes(filterType) &&
+    value.match(/^(?<val>[1-9]\d*)(?<unit>d|m|y)$/)?.groups?.unit
+  ) {
+    const { val, unit } =
+      value.match(/^(?<val>[1-9]\d*)(?<unit>d|m|y)$/)?.groups || {};
+    const min =
+      (unit === "d" ? dt(dp.y, dp.m, dp.d - +val) : null) ||
+      (unit === "m" ? dt(dp.y, dp.m - +val, dp.d) : null) ||
+      (unit === "y" ? dt(dp.y - +val, dp.m, dp.d) : null);
+    return {
+      min,
+      max: dt(dp.y, dp.m, dp.d),
+      isvalid: isValidDate(min),
+    };
+  }
+
+  // specific quarter - before skip date value validation
+  if (
+    ["date", "datepicker"].includes(filterType) &&
+    value.match(/^(?<year>\d{4})-q(?<quarter>[1-4])$/)?.groups?.quarter
+  ) {
+    const { year, quarter } =
+      value.match(/^(?<year>\d{4})-q(?<quarter>[1-4])$/)?.groups || {};
+    const startMonth = +quarter * 3;
+    return {
+      min: dt(year, startMonth - 3, 1),
+      max: dt(year, startMonth, 0),
+      isvalid: true,
+    };
+  }
+
+  // date value validation
+  if (
+    ["date", "datepicker"].includes(filterType) &&
+    !sep &&
+    !isValidDate(value)
+  ) {
+    return { isvalid: false };
+  }
+
+  // specific date / day
+  if (
+    ["date", "datepicker"].includes(filterType) &&
+    value.match(/^\d{4}-\d{2}-\d{2}$/)?.[0]
+  ) {
+    return {
+      min: new Date(value).toISOString().split("T")[0],
+      max: new Date(value).toISOString().split("T")[0],
+      isvalid: true,
+    };
+  }
+
+  // specific month
+  if (
+    ["date", "datepicker"].includes(filterType) &&
+    value.match(/^\d{4}-\d{2}$/)?.[0]
+  ) {
+    return {
+      min: new Date(value).toISOString().split("T")[0],
+      max: dt(new Date(value).getFullYear(), new Date(value).getMonth() + 1, 0),
+      isvalid: true,
+    };
+  }
+
+  // specific year
+  if (
+    ["date", "datepicker"].includes(filterType) &&
+    value.match(/^\d{4}$/)?.[0]
+  ) {
+    return {
+      min: dt(value, 0, 1),
+      max: dt(value, 11, 31),
+      isvalid: true,
+    };
+  }
+
+  if (sep) {
+    const [minValue = "min", maxValue = "max"] = value.split(sep);
+    // range for numbers
+    if (filterType === "range" && fieldType) {
+      const isvalid =
+        (numberTypeList.includes(fieldType) || sql) &&
+        isValidNumber(minValue) &&
+        isValidNumber(maxValue);
+      return { min: minValue, max: maxValue, isvalid };
+    }
+
+    // date range, example: 01.01.2024-31.12.2024
+    if (["date", "datepicker"].includes(filterType)) {
+      const min = minValue === "min" ? minValue : formatDateISOString(minValue);
+      const max = maxValue === "max" ? maxValue : formatDateISOString(maxValue);
+      const isvalid =
+        fieldType &&
+        (dateTypeList.includes(fieldType) || sql) &&
+        isValidDate(min) &&
+        isValidDate(max);
+      return { min, max, isvalid };
+    }
+  }
+
+  return { isvalid: false };
+}
+export default function getRangeQuery({
+  value,
+  name,
+  fieldType,
+  filterType,
+  sql,
+  args: argsParams,
+}) {
+  const { min, max, isvalid } = checkValid(
+    value,
+    fieldType,
+    filterType,
+    sql,
+  );
+  if (!isvalid) {
+    return { query: "false" };
+  }
+
+  const args = Array.from(argsParams || []);
+
+  const checkBoth =
+    sql && typeof sql === "string" && sql.includes("$1") && sql.includes("$2");
+
+  // with sql subquery
+  if (
+    filterType &&
+    ["date", "datepicker"].includes(filterType) &&
+    typeof sql === "string"
+  ) {
+    if (checkBoth) {
+      args.push(min);
+      args.push(max);
+    } else {
+      args.push(min || max);
+    }
+
+    return {
+      query: sql,
+      values: checkBoth ? [min, max] : [min || max],
+    };
+  }
+  // with sql subquery
+  if (filterType && ["range"].includes(filterType) && sql) {
+    if (checkBoth) {
+      args.push(min);
+      args.push(max);
+    } else {
+      args.push(min || max);
+    }
+
+    return {
+      query: sql,
+      values: checkBoth ? [min, max] : [min || max],
+    };
+  }
+
+  // preset date values
+  if (
+    filterType &&
+    ["date", "datepicker"].includes(filterType) &&
+    ["cd", "cw", "cm", "cq", "cy"].includes(value)
+  ) {
+    if (value === "cd") {
+      args.push(min);
+    } else {
+      args.push(min);
+      args.push(max);
+    }
+
+    const query =
+      value === "cd"
+        ? `${name}::date = $${args.length}::date`
+        : `${name}::date between $${args.length - 1}::date and $${args.length
+        }::date`;
+    return { query, values: value === "cd" ? [min] : [min, max] };
+  }
+
+  // same date
+  if (
+    filterType &&
+    ["date", "datepicker"].includes(filterType) &&
+    max &&
+    min &&
+    min === max
+  ) {
+    args.push(min);
+    return { query: `${name}::date = $${args.length}::date`, values: [min] };
+  }
+
+  // skip, same as 1=1
+  if (
+    filterType &&
+    ["range"].includes(filterType) &&
+    min === "min" &&
+    max === "max"
+  ) {
+    return { query: "true" };
+  }
+
+  // default
+  if (filterType && max === "max") {
+    args.push(min);
+    const query = ["date", "datepicker"].includes(filterType)
+      ? `${name} >= $${args.length}::date`
+      : `${name} >= $${args.length}`;
+    return {
+      query,
+      values: [min],
+    };
+  }
+
+  if (filterType && min === "min") {
+    args.push(max);
+    const query = ["date", "datepicker"].includes(filterType)
+      ? `${name} <= $${args.length}::date`
+      : `${name} <= $${args.length}`;
+    return { query, values: [max] };
+  }
+
+  if (filterType && ["date", "datepicker"].includes(filterType)) {
+    args.push(min);
+    args.push(max);
+    return {
+      query: `${name}::date between $${args.length - 1}::date and $${args.length
+        }::date`,
+      values: [min, max],
+    };
+  }
+
+  args.push(min);
+  args.push(max);
+  return {
+    query: `${name} between $${args.length - 1} and $${args.length}`,
+    values: [min, max],
+  };
+}

package/server/routes/registers/functions/getFilterSQLParametrized/index.js

@@ -0,0 +1,81 @@
+import { BadRequestError } from "@opengis/fastify-table/errors.js";
+import { pgClients } from "@opengis/fastify-table/utils.js";
+
+// filter util
+import getFilterQuery from "./getFilterQuery.js";
+
+export default function getFilterSQLParametrized({
+  table,
+  fields = [],
+  filter,
+  search,
+  searchColumn: searchColumn1,
+  filterList,
+  query,
+  uid,
+}, pg = pgClients.client) {
+  if (!pg) {
+    throw new Error("empty pg");
+  }
+
+  if (!table) {
+    throw BadRequestError("param table is required");
+  }
+
+  if (!pg.pk[table]) {
+    throw BadRequestError("param table is invalid");
+  }
+
+  const args = Array.from([]);
+
+  const autoSearchColumn = fields
+    ?.filter((el) => pg.pgType?.[el.dataTypeID] === "text")
+    ?.map((el) => `"${el.name}"`)
+    .join(",");
+
+  const searchColumn =
+    searchColumn1 ||
+    autoSearchColumn;
+
+  const where = [];
+
+
+  if (search && searchColumn && typeof search === "string") {
+    args.push(
+      `%${decodeURIComponent(search.replace(/%/g, "%25")).replace(
+        /%/g,
+        "\\%"
+      )}%`
+    );
+    where.push(
+      `(${searchColumn
+        .split(",")
+        ?.map((name) => `${name}::text ilike $${args.length}`)
+        ?.join(" or ")})`
+    );
+  }
+
+  const filters = getFilterQuery(
+    {
+      filter,
+      table,
+      fields,
+      filterList,
+      uid,
+      args,
+    },
+    pg
+  );
+
+  const filterQuery = filters
+    .filter((el) => el.query)
+    .map((el) => `${el.query}`)
+    .join(" and ");
+
+  const q = where
+    .concat([query, filterQuery])
+    .filter(Boolean)
+    .join(" and ");
+
+  return { q, args };
+}

package/server/routes/registers/functions/getTableColumnMeta.js

@@ -0,0 +1,125 @@
+import {
+    pgClients,
+    getTemplate,
+    getMeta,
+    getSelect,
+    getFilter,
+} from "@opengis/fastify-table/utils.js";
+
+const defaultLimit = 50;
+
+export default async function getTableColumnMeta(
+    {
+        table,
+        template,
+        column: queryColumn,
+        filtered,
+        startsWith,
+        key,
+    },
+    pg = pgClients.client
+) {
+    if (!table || !queryColumn) {
+        return null;
+    }
+
+    const metaColumns = await getMeta(
+        {
+            pg,
+            table,
+        },
+    ).then((r) => r?.columns || []);
+
+    const { dataTypeID } =
+        (metaColumns || []).find((col) => col?.name === queryColumn) || {};
+
+    const { table: tableName, sql } = template
+        ? await getTemplate("table", template)
+        : { table };
+
+    const filters = template
+        ? await getFilter({ pg, table: template }).then((el) => el.list)
+        : null;
+
+    const { data: clsName } =
+        (filters || []).find((el) => el.name === queryColumn) || {};
+    const { arr, sql: select } =
+        (await getSelect(clsName || queryColumn, pg)) || // cls name === table:column
+        (await getSelect(queryColumn, pg)) || // cls name === column name
+        {};
+
+    const sqlTable =
+        (sql || [])
+            .filter(
+                (el) =>
+                    !el.disabled && el.sql && el.sql.includes(queryColumn) && false
+            )
+            .map(
+                (el, i) =>
+                    ` left join lateral (${el.sql}) ${el.name || `t${i}`} on 1=1 `
+            )
+            ?.join("") || "";
+
+    if (arr?.length && !arr.find((el) => el.id === "null")) {
+        arr.push({
+            color: "#B8B8B8",
+            icon: null,
+            id: "null",
+            text: "Показати порожні значення",
+        });
+    }
+
+    // w/out select
+    const searchQueryDefault =
+        startsWith && key
+            ? `(left(lower("text"::text),${key.length}) = $1 )`
+            : '(lower("text"::text) ~ $1 )';
+
+    // w/ select
+    const searchQuerySelect =
+        startsWith && key
+            ? `id in ( with cc(id, text) as (${select}) select id from cc where (left(lower("text"),${key.length})=$1) )`
+            : `id in ( with cc(id, text) as (${select}) select id from cc where (lower("text") ~ $1) )`;
+
+    if (pg.pgType?.[dataTypeID]?.includes("[]")) {
+        const original = filtered
+            ? `with c(id,text) as (select id, id as text from (select unnest("${queryColumn.replace(
+                /"/g,
+                ""
+            )}") as id from ${tableName} t ${sqlTable})q group by id) select id, text from c`
+            : `with c(id,text) as (select id, id as text, count(*) from (select unnest("${queryColumn.replace(
+                /"/g,
+                ""
+            )}") as id from ${tableName} t ${sqlTable})q group by id limit ${defaultLimit}) select * from c`;
+
+        return {
+            arr,
+            original,
+            searchQuery: select ? searchQuerySelect : searchQueryDefault,
+            pk: "id",
+        };
+    }
+
+    const original = filtered
+        ? `with c(id,text) as (select rtrim( replace( replace( replace( encode("${queryColumn.replace(/"/g, '')}"::bytea, 'base64'), '+', '' ), '-', '' ), '/', '' ), '=' ) as id, "${queryColumn.replace(
+            /"/g,
+            ""
+        )}" as text from ${tableName} t ${sqlTable} group by "${queryColumn.replace(
+            /"/g,
+            ""
+        )}") select id, text from c`
+        : `with c(id,text) as (select rtrim( replace( replace( replace( encode("${queryColumn.replace(/"/g, '')}"::bytea, 'base64'), '+', '' ), '-', '' ), '/', '' ), '=' ) as id, "${queryColumn.replace(
+            /"/g,
+            ""
+        )}" as text, count(*) from ${tableName} t ${sqlTable} group by "${queryColumn.replace(
+            /"/g,
+            ""
+        )}" limit ${defaultLimit}) select * from c`;
+
+    return {
+        arr,
+        original,
+        searchQuery: select ? searchQuerySelect : searchQueryDefault,
+        pk: "id",
+    };
+}