@opengis/fastify-table 2.4.1 → 2.4.2

package/dist/server/routes/access/controllers/access.interface.js

@@ -1,19 +1,19 @@
 // import { type ExtendedRequest } from "../../../types/core.js";
 import { pgClients, metaFormat, getAdminAccess } from "../../../../utils.js";
-const q = `select a.route_id as id, coalesce(b.user_uid, d.user_uid) as user_uid, coalesce(d.actions, b.actions, array['view']) as actions, b.scope, c.role_id
-from admin.routes a 
-left join admin.role_access b on 
-  a.route_id=b.route_id
-left join admin.roles c on 
-  b.role_id=c.role_id 
-  and c.enabled
-left join admin.user_roles d on 
-  c.role_id=d.role_id 
-  and ( case when 
-            d.expiration is not null 
-            then d.expiration > CURRENT_DATE 
-            else 1=1 
-        end )
+const q = `select a.route_id as id, coalesce(b.user_uid, d.user_uid) as user_uid, coalesce(d.actions, b.actions, array['view']) as actions, b.scope, c.role_id
+from admin.routes a 
+left join admin.role_access b on 
+  a.route_id=b.route_id
+left join admin.roles c on 
+  b.role_id=c.role_id 
+  and c.enabled
+left join admin.user_roles d on 
+  c.role_id=d.role_id 
+  and ( case when 
+            d.expiration is not null 
+            then d.expiration > CURRENT_DATE 
+            else 1=1 
+        end )
 where $1 in (a.route_id, a.alias, a.table_name) and coalesce(b.user_uid, d.user_uid) is not null`;
 export default async function accessInterface(req, reply) {
     const { pg = pgClients.client, params = {}, user = {}, unittest } = req;

package/dist/server/routes/access/controllers/access.user.js

@@ -6,18 +6,18 @@ export default async function accessUser(req) {
     }
     const { pg = pgClients.client } = req;
     const routes = await pg
-        .query(`select a.route_id as path, b.actions from admin.routes a 
-    left join admin.role_access b on a.route_id=b.route_id
+        .query(`select a.route_id as path, b.actions from admin.routes a 
+    left join admin.role_access b on a.route_id=b.route_id
     where b.user_uid=$1`, [req.params.id])
         .then((el) => el.rows || []);
     const resources = await pg
-        .query(`select resource_id, actions from admin.role_access
+        .query(`select resource_id, actions from admin.role_access
 where resource_id is not null and user_uid=$1`, [req.params.id])
         .then((el) => el.rows || []);
     const user = await pg
-        .query(`select user_uid as id, user_name as name, access_granted, 
-    b.cdate as user_created, b.last_activity_date as last_activity from admin.user_roles a
-    left join admin.users b on a.user_uid=b.uid
+        .query(`select user_uid as id, user_name as name, access_granted, 
+    b.cdate as user_created, b.last_activity_date as last_activity from admin.user_roles a
+    left join admin.users b on a.user_uid=b.uid
     where a.user_uid=$1`, [req.params.id])
         .then((el) => el.rows?.[0]);
     return { routes, resources, user };

package/dist/server/routes/auth/controllers/2factor/providers/totp.js

@@ -18,20 +18,20 @@ const deleteSecret = async ({ uid, pg }) => {
 };
 const getSecret = async ({ uid, pg }) => {
     const { social_auth_code: secret, enabled, recoveryCodes, } = await pg
-        .query(`select social_auth_code, enabled, social_auth_obj->'codesArray' as "recoveryCodes"
-    from admin.users_social_auth 
+        .query(`select social_auth_code, enabled, social_auth_obj->'codesArray' as "recoveryCodes"
+    from admin.users_social_auth 
     where uid = $1 and social_auth_type = $2`, [uid, TYPE])
         .then((el) => el.rows?.[0] || {});
     return { secret, enabled, recoveryCodes };
 };
 const addSecret = async ({ uid, secret, pg, recoveryCodes, otp }) => {
-    await pg.query(`insert into admin.users_social_auth(uid, social_auth_code, social_auth_type, social_auth_obj, social_auth_url, enabled)
+    await pg.query(`insert into admin.users_social_auth(uid, social_auth_code, social_auth_type, social_auth_obj, social_auth_url, enabled)
     values($1, $2, $3, $4::json, $5, false)`, [uid, secret, TYPE, { codesArray: recoveryCodes }, otp]);
 };
 const updateSecret = async ({ uid, pg, secret, recoveryCodes, otp }) => {
     const result = await pg
-        .query(`update admin.users_social_auth
-    set social_auth_code=$3, social_auth_obj=$4::json, social_auth_url=$5
+        .query(`update admin.users_social_auth
+    set social_auth_code=$3, social_auth_obj=$4::json, social_auth_url=$5
     where uid = $1 and social_auth_type = $2`, [uid, TYPE, secret, { codesArray: recoveryCodes }, otp])
         .then((el) => el.rows?.[0] || {});
     return result;

package/dist/server/routes/auth/controllers/2factor/qrcode.js

@@ -24,7 +24,7 @@ export default async function qrCode(req, reply) {
     const { enabled, secret } = await getSecret({ pg, uid });
     const { otp } = secret
         ? await pg
-            .query(`select social_auth_url as otp from admin.users_social_auth 
+            .query(`select social_auth_url as otp from admin.users_social_auth 
           where uid=$1 and social_auth_type=$2`, [uid, "TOTP"])
             ?.then((el) => el.rows?.[0] || {})
         : await generate({ uid, pg });

package/dist/server/routes/auth/controllers/2factor/recovery.js

@@ -48,7 +48,7 @@ export default async function recovery(req, reply) {
         const pt = customPt ||
             (await readFile(path.join(dirname, `../../../../../templates/pt/${template}.html`), "utf8"));
         const recoveryCodes = await pg
-            .query(`select social_auth_obj->'codesArray' as "recoveryCodes" from admin.users_social_auth 
+            .query(`select social_auth_obj->'codesArray' as "recoveryCodes" from admin.users_social_auth 
       where uid = $1 and social_auth_type = $2`, [uid, "TOTP"])
             .then((el) => el.rows?.[0]?.recoveryCodes || []);
         if (!recoveryCodes?.length) {

package/dist/server/routes/auth/controllers/2factor/verify.js

@@ -48,7 +48,7 @@ export default async function verifyFunction(req, reply) {
     req.session.secondFactorPassed = true;
     if (!enabled && email) {
         const { recoveryCodes } = await pg
-            .query(`select social_auth_obj->'codesArray' as "recoveryCodes" 
+            .query(`select social_auth_obj->'codesArray' as "recoveryCodes" 
       from admin.users_social_auth where uid=$1 and social_auth_type='TOTP'`, [uid])
             ?.then((el) => el.rows?.[0] || {});
         const customPt = await getTemplate("pt", template);

package/dist/server/routes/auth/controllers/core/getUserInfo.js

@@ -5,31 +5,31 @@ import applyHook from "../../../../plugins/hook/applyHook.js";
 import getRedis from "../../../../plugins/redis/funcs/getRedis.js";
 import getUserPermissions from "../../../../plugins/access/funcs/getUserPermissions.js";
 const rclient2 = getRedis({ db: 2 });
-const q = `select
-
-  a.route_id as id, 
-  /* coalesce(d.actions, array['view', 'edit','add','del']) as role_actions,
-  coalesce(b.actions, array['view']) as interface_actions, */
-  array_intersect(coalesce(b.actions, array['view']), coalesce(d.actions, array['view', 'edit','add','del'])) as actions,
-  b.scope,
-  c.role_id,
-  c.name as role_name
-
-from admin.routes a 
-left join admin.role_access b on 
-  a.route_id=b.route_id
-left join admin.roles c on 
-  b.role_id=c.role_id 
-  and c.enabled
-left join admin.user_roles d on 
-  c.role_id=d.role_id
-  and (
-    case when
-      d.expiration is not null 
-      then d.expiration > CURRENT_DATE 
-      else 1=1 
-    end
-  )
+const q = `select
+
+  a.route_id as id, 
+  /* coalesce(d.actions, array['view', 'edit','add','del']) as role_actions,
+  coalesce(b.actions, array['view']) as interface_actions, */
+  array_intersect(coalesce(b.actions, array['view']), coalesce(d.actions, array['view', 'edit','add','del'])) as actions,
+  b.scope,
+  c.role_id,
+  c.name as role_name
+
+from admin.routes a 
+left join admin.role_access b on 
+  a.route_id=b.route_id
+left join admin.roles c on 
+  b.role_id=c.role_id 
+  and c.enabled
+left join admin.user_roles d on 
+  c.role_id=d.role_id
+  and (
+    case when
+      d.expiration is not null 
+      then d.expiration > CURRENT_DATE 
+      else 1=1 
+    end
+  )
 where $1 in (b.user_uid, d.user_uid)`;
 export default async function getUserInfo(req) {
     const { pg = pgClients.client, user, session, cookies } = req;
@@ -53,14 +53,14 @@ export default async function getUserInfo(req) {
         : config.settingKeys || ["site", "map", "admin"];
     const settings = pg?.pk?.["admin.properties"]
         ? await pg
-            .query(`select 
-        property_key as key, 
-        case
-          when property_text is not null then to_jsonb(property_text)
-          when property_int is not null then to_jsonb(property_int) 
-          when property_json is not null then property_json::jsonb 
-        end as val 
-        from admin.properties 
+            .query(`select 
+        property_key as key, 
+        case
+          when property_text is not null then to_jsonb(property_text)
+          when property_int is not null then to_jsonb(property_int) 
+          when property_json is not null then property_json::jsonb 
+        end as val 
+        from admin.properties 
         where property_key like any($1)`, [settingKeys.map((key) => `${key}%`)])
             .then((el) => el.rows.reduce((p, { key, val }) => {
             const [k1, k2] = key.split(".");

package/dist/server/routes/auth/controllers/core/passwordRecovery.js

@@ -78,7 +78,7 @@ export default async function passwordRecovery(req, reply) {
         if (config.pg) {
             await pg.query(q, [code, body.email]);
         }
-        const userQuery = `select coalesce(sur_name,'')|| coalesce(' '||user_name,'')||coalesce(' '||father_name,'') as user 
+        const userQuery = `select coalesce(sur_name,'')|| coalesce(' '||user_name,'')||coalesce(' '||father_name,'') as user 
     from admin.users where $1 in (login,email) limit 1`;
         const userName = config.pg
             ? await pg

package/dist/server/routes/auth/controllers/core/registration.js

@@ -84,8 +84,8 @@ export default async function registration(req, reply) {
         const { uid } = await pg
             .query(q3, [login])
             .then((el) => el.rows?.[0] || {});
-        await pg.query(`insert into admin.users (uid, login, password, user_name, sur_name, father_name, email,phone, enabled, user_personal_code )
-    select contact_id, $4, $3, first_name, last_name, middle_name, $2, phone, true, md5(random()::text) 
+        await pg.query(`insert into admin.users (uid, login, password, user_name, sur_name, father_name, email,phone, enabled, user_personal_code )
+    select contact_id, $4, $3, first_name, last_name, middle_name, $2, phone, true, md5(random()::text) 
     from crm_acc.crm_contact where contact_id = $1 and contact_id not in (select uid from admin.users)`, [uid, email, password, login]);
     }
     else {

package/dist/server/routes/auth/controllers/page/login2faTemplate.js

@@ -37,7 +37,7 @@ export default async function loginTemplate(req, reply) {
     const { enabled, secret } = config.pg ? await getSecret({ pg, uid }) : {};
     const { otp, recoveryCodes, key } = secret && pg?.pk?.["admin.users_social_auth"]
         ? await pg
-            .query(`select social_auth_obj->'codesArray' as "recoveryCodes", enabled, social_auth_url as otp 
+            .query(`select social_auth_obj->'codesArray' as "recoveryCodes", enabled, social_auth_url as otp 
   from admin.users_social_auth where uid=$1 and social_auth_type='TOTP'`, [uid])
             ?.then((el) => el.rows?.[0] || {})
         : await generate({ uid, pg });

package/dist/server/routes/file/controllers/resizeAll.js

@@ -69,9 +69,9 @@ export default async function resizeAll(req, reply) {
     const { pg = pgClients.client, query = {} } = req;
     const { nocache, filepath, quality = 80, limit, sql, w = 2048 } = query;
     if (nocache) {
-        const clearQ = `update crm.files set resized=null 
-    where ext=any($1) 
-    and ${filepath ? "file_path=$2" : "1=1"} 
+        const clearQ = `update crm.files set resized=null 
+    where ext=any($1) 
+    and ${filepath ? "file_path=$2" : "1=1"} 
     and resized is not null`;
         if (sql)
             return clearQ;
@@ -79,9 +79,9 @@ export default async function resizeAll(req, reply) {
         return reply.status(200).send({ msg: "clear cache success", rowCount });
     }
     const resizeQuality = Math.min(quality, 100);
-    const q = `select file_id as id, file_path as relpath from crm.files
-  where ext=any($1)
-  and ${filepath ? "file_path=$2" : "1=1"} 
+    const q = `select file_id as id, file_path as relpath from crm.files
+  where ext=any($1)
+  and ${filepath ? "file_path=$2" : "1=1"} 
   and resized is null ${limit ? `limit ${limit}` : ""}`;
     if (sql)
         return q;

package/dist/server/routes/grpc/controllers/file2geojson.js

@@ -23,19 +23,19 @@ export default async function file2geojson({ pg = pgClients.client, body = {}, }
         const JsonArr = JsonData?.features
             ? JsonData
             : { type: "FeatureCollection", features: [JsonData] };
-        const { rows = [] } = await pg.query(`
-        select 
-        features->>'type' as type,
-        features->'properties' as properties,
-        st_asgeojson(st_transform(st_setsrid(st_geomfromgeojson(features->>'geometry'),$2),4326))::json as geometry        
-        from (
-        select d->>'type' as type,d->>'name' as name,json_array_elements(d->'features') as features 
-        from (
-            select  json_array_elements(case when json_typeof(d)='array' then d else json_build_array(d) end)d
-            from (
-            select ($1)::json as d
-            )q
-        )q
+        const { rows = [] } = await pg.query(`
+        select 
+        features->>'type' as type,
+        features->'properties' as properties,
+        st_asgeojson(st_transform(st_setsrid(st_geomfromgeojson(features->>'geometry'),$2),4326))::json as geometry        
+        from (
+        select d->>'type' as type,d->>'name' as name,json_array_elements(d->'features') as features 
+        from (
+            select  json_array_elements(case when json_typeof(d)='array' then d else json_build_array(d) end)d
+            from (
+            select ($1)::json as d
+            )q
+        )q
     )q`, [JSON.stringify(JsonArr).replace(/'/g, "''"), srid]);
         return [{ features: [rows.slice(0, 1)] }];
     }

package/dist/server/routes/menu/controllers/getMenu.js

@@ -75,15 +75,15 @@ export default async function adminMenu({ user = {}, session, pg = pgClients.cli
         user.user_type !== "viewer" &&
         pg.pk?.["admin.role_access"]) {
         const { type, gl = [], routes = [], } = await pg
-            .query(`select user_type as type, b.gl,routes from admin.users a
-        left join lateral (
-            select array_agg(role_id) as gl from admin.user_roles 
-            where   user_uid=a.uid 
-            and     role_id in ( select role_id from admin.roles where enabled)
-        )b on 1=1
-        left join lateral (
-            select array_agg(route_id) as routes from admin.role_access where role_id=any(b.gl)
-        )r on 1=1
+            .query(`select user_type as type, b.gl,routes from admin.users a
+        left join lateral (
+            select array_agg(role_id) as gl from admin.user_roles 
+            where   user_uid=a.uid 
+            and     role_id in ( select role_id from admin.roles where enabled)
+        )b on 1=1
+        left join lateral (
+            select array_agg(route_id) as routes from admin.role_access where role_id=any(b.gl)
+        )r on 1=1
         where uid=$1`, [user.uid])
             .then((el) => el.rows[0] || {});
         /* const { interfaces = [] } = await pg.query(`select array_agg(route_id) as interfaces from admin.role_access

package/dist/server/routes/notifications/controllers/readNotifications.js

@@ -7,10 +7,10 @@ export default async function readNotifications(req) {
     }
     const ids = pg && pg.pk?.["crm.notifications"]
         ? await pg
-            .query(`update crm.notifications
-    set read=true
-    where read is not true
-    and addressee_id=$1
+            .query(`update crm.notifications
+    set read=true
+    where read is not true
+    and addressee_id=$1
     and ${params.id ? "notification_id=$2" : "1=1"} returning notification_id`, [user.uid, params?.id].filter(Boolean))
             .then((el) => el.rows?.map((row) => row.notification_id) || [])
         : [];

package/dist/server/routes/notifications/controllers/userNotifications.js

@@ -2,9 +2,9 @@ import pgClients from "../../../plugins/pg/pgClients.js";
 import getSelectVal from "../../../plugins/table/funcs/metaFormat/getSelectVal.js";
 import { UnauthorizedError } from "../../../../errors.js";
 const maxLimit = 100;
-const q = `select notification_id as id, subject, body, created_at,
-author_id, read, link, entity_id, (select avatar from admin.users where uid=a.author_id limit 1) as avatar
-from crm.notifications a
+const q = `select notification_id as id, subject, body, created_at,
+author_id, read, link, entity_id, (select avatar from admin.users where uid=a.author_id limit 1) as avatar
+from crm.notifications a
 where addressee_id=$1 order by created_at desc limit $2 offset $3`;
 export default async function userNotifications(req) {
     const { pg = pgClients.client, query, user, } = req;

package/dist/server/routes/table/controllers/card.js

@@ -57,7 +57,7 @@ export default async function card(req, reply) {
         : "";
     const q = `select  ${pk ? `"${pk}" as id,` : ""} ${dbColumns.find((el) => el.name === "geom" && pg.pgType[el.dataTypeID] === "geometry")
         ? "st_asgeojson(geom)::json as geom,"
-        : ""} ${cols || "*"} ${cardColumns} from ${table} t ${sqlTable} ${cardSqlTable} 
+        : ""} ${cols || "*"} ${cardColumns} from ${table} t ${sqlTable} ${cardSqlTable} 
   where ${where.join(" and ") || "true"} limit 1`;
     if (query.sql === "1") {
         return q;

package/dist/server/routes/table/controllers/filter.js

@@ -153,12 +153,12 @@ export default async function filterAPI(req, reply, iscalled) {
         fields?.find?.((item) => item?.name === el.name))
         .map(async (el) => {
         const data = await pg
-            .queryCache(`select array[
-        min(${el.name}),
-        percentile_disc(0.25) within group (order by ${el.name}),
-        percentile_disc(0.5) within group (order by ${el.name}),
-        percentile_disc(0.75) within group (order by ${el.name}),
-        max(${el.name})
+            .queryCache(`select array[
+        min(${el.name}),
+        percentile_disc(0.25) within group (order by ${el.name}),
+        percentile_disc(0.5) within group (order by ${el.name}),
+        percentile_disc(0.75) within group (order by ${el.name}),
+        max(${el.name})
     ] as range from ${table} where ${tableQuery || "1=1"}`, { table })
             .then((res) => {
             if (res.timeout) {

package/dist/server/routes/table/controllers/form.js

@@ -1,6 +1,6 @@
 import { NotFoundError } from "../../../../errors.js";
 import { applyHook, getTemplate, pgClients } from "../../../../utils.js";
-const q = `select property_key as key, property_json as json, property_int as int,
+const q = `select property_key as key, property_json as json, property_int as int,
 property_text as text from admin.properties where 1=1`;
 async function getSettings({ pg }) {
     const rows = pg?.pk?.["admin.properties"]

package/dist/server/routes/table/controllers/getFormByTable.js

@@ -9,12 +9,12 @@ import getTemplate from "../../../plugins/table/funcs/getTemplate.js";
 import getEditData from "../../crud/controllers/table.js";
 import formatSchema from "./utils/formatSchema.js";
 import { ForbiddenError, NotFoundError, UnauthorizedError, } from "../../../../errors.js";
-const q = `select
-    property_key as key,
-    property_json as json,
-    property_int as int,
-    property_text as text
-from admin.properties
+const q = `select
+    property_key as key,
+    property_json as json,
+    property_int as int,
+    property_text as text
+from admin.properties
 where 1=1`;
 export default async function getForm({ pg = pgClients.client, params, user = {}, query = {}, method, }, reply) {
     const time = Date.now();

package/dist/server/routes/table/controllers/suggest.js

@@ -254,9 +254,9 @@ export default async function suggest(req) {
         .filter(Boolean)
         .join(" and ") || "true";
     const sqlSuggest = tableName && column
-        ? `${meta.original}
-          WHERE EXISTS ( SELECT 1 FROM ${tableName} o WHERE o.${column} IS NOT DISTINCT FROM c.id ) and ${val || "true"} and ${search || "true"}
-          ${meta.original.toLowerCase().includes("order by") ? "" : "order by 2"}
+        ? `${meta.original}
+          WHERE EXISTS ( SELECT 1 FROM ${tableName} o WHERE o.${column} IS NOT DISTINCT FROM c.id ) and ${val || "true"} and ${search || "true"}
+          ${meta.original.toLowerCase().includes("order by") ? "" : "order by 2"}
           LIMIT ${Math.min(query.limit || meta.limit || limit, limit)}`
             .replace(/{{parent}}/gi, parent)
             .replace(/{{uid}}/g, user?.uid || "0")

package/dist/server/routes/table/controllers/tableData.js

@@ -3,8 +3,8 @@ import getData from "../functions/getData.js";
 export default async function tableData(req, reply, called) {
     const { user, params, headers, query, pg = pgClients.client } = req;
     // це можна від користувача
-    const q = `select attr,
-    (select rule_values from admin.account_grants where account_id in (select account_id from admin.account_users where user_uid=$2) and rule_id=r.rule_id limit 1) 
+    const q = `select attr,
+    (select rule_values from admin.account_grants where account_id in (select account_id from admin.account_users where user_uid=$2) and rule_id=r.rule_id limit 1) 
     from admin.rules r where (select route_id from admin.routes where $1 in (alias,table_name)) = any(routes)`;
     const { rows = [] } = pg?.pk?.["admin.rules"] && pg?.pk?.["admin.account_grants"] && user?.uid
         ? await pg.query(q, [params.table, user.uid])

package/dist/server/routes/table/controllers/tableInfo.js

@@ -59,21 +59,21 @@ export default async function tableInfo({ pg = pgClients.client, params, query =
     if (!metaInfoCols.length) {
         throw BadRequestError("invalid meta info: columns not found");
     }
-    const q = `select  ${pk ? `"${pk}" as id,` : ""} 
-                        ${metaInfoCols.join(",")} 
-                        from (select * from ${table} where ${sqlTable ? "true" : where.join(" and ") || "true"}) t 
-                        ${sqlTable} 
-                        ${cardSqlTable} 
-                        where ${where.join(" and ") || "true"} 
+    const q = `select  ${pk ? `"${pk}" as id,` : ""} 
+                        ${metaInfoCols.join(",")} 
+                        from (select * from ${table} where ${sqlTable ? "true" : where.join(" and ") || "true"}) t 
+                        ${sqlTable} 
+                        ${cardSqlTable} 
+                        where ${where.join(" and ") || "true"} 
                         limit 1`.replace(/{{uid}}/g, uid);
     if (query.sql === "1") {
         return q;
     }
     const { rows } = await pg.query(q, [params.id]);
-    const qCount = `select 
-                count(*)::int as total,  
-                count(*) FILTER(WHERE ${[interfaceQuery].filter((el) => el).join(" and ") || "true"})::int as filtered 
-                from ${table} t ${sqlTable} 
+    const qCount = `select 
+                count(*)::int as total,  
+                count(*) FILTER(WHERE ${[interfaceQuery].filter((el) => el).join(" and ") || "true"})::int as filtered 
+                from ${table} t ${sqlTable} 
                 where ${[loadTable.query].filter((el) => el).join(" and ") || "true"} `.replace(/{{uid}}/g, uid);
     const { total, filtered } = params.id
         ? rows.length

package/dist/server/routes/table/functions/getData.js

@@ -333,24 +333,24 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
     ]
         .filter(Boolean)
         .filter((el) => checkQuery(el));
-    const q = `select  ${pk ? `"${pk}" as id,` : ""} 
+    const q = `select  ${pk ? `"${pk}" as id,` : ""} 
                      ${objectId || query?.key
         ? "*"
-        : columnsParam || sqlColumns || cols || "*"} 
-                     ${metaCols}
+        : columnsParam || sqlColumns || cols || "*"} 
+                     ${metaCols}
                      ${dbColumns.filter((el) => pg.pgType?.[el.dataTypeID] === "geometry").length && !columnsParam
         ? `,${dbColumns
             .filter((el) => pg.pgType?.[el.dataTypeID] === "geometry")
             .map((el) => `st_asgeojson("${el.name.replace(/'/g, "''")}")::json as "${el.name.replace(/'/g, "''")}"`)
             .join(",")}`
-        : ""} 
+        : ""} 
                      from (select * ${sql
         ?.filter((el) => el.inline && !(isExport && el.export === false))
         .map((el) => `,(${el.sql})`)
-        .join("") || ""} from ${viewSql ? `(${viewSql})` : table1} t  ${sqlTable} ) t 
-                      
-                     ${objectId ? cardSqlTable : ""} 
-                     where ${where.join(" and ") || "true"} 
+        .join("") || ""} from ${viewSql ? `(${viewSql})` : table1} t  ${sqlTable} ) t 
+                      
+                     ${objectId ? cardSqlTable : ""} 
+                     where ${where.join(" and ") || "true"} 
                      ${order} ${offset} limit ${limit}`.replace(/{{uid}}/g, uid);
     if (config.trace)
         console.log(q);
@@ -415,18 +415,18 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
         type: pg.pgType?.[el.dataTypeID],
     }))
         .filter((el) => ["numeric", "double precision"].includes(el.type) && aggColumns[el.name]);
-    const qCount = `select 
-            count(*)::int as total,  
-            count(*) FILTER(WHERE ${filterWhere.join(" and ") || "true"})::int as filtered
+    const qCount = `select 
+            count(*)::int as total,  
+            count(*) FILTER(WHERE ${filterWhere.join(" and ") || "true"})::int as filtered
             ${aggregates.length
         ? `,${aggregates
             .map((el) => `${aggColumns[el.name]}(${el.name}) FILTER(WHERE ${filterWhere.join(" and ") || "true"}) as ${el.name}`)
             .join(",")}`
-        : ""}
+        : ""}
             from (select * ${sql
         ?.filter((el) => el.inline)
         .map((el) => `,(${el.sql})`)
-        .join("") || ""} from ${viewSql ? `(${viewSql})` : table1} t ${sqlTable})t 
+        .join("") || ""} from ${viewSql ? `(${viewSql})` : table1} t ${sqlTable})t 
             where ${[loadTable?.query, tokenData?.query, accessQuery, contextQuery]
         .filter(Boolean)
         .filter((el) => checkQuery(el))

package/dist/server/routes/widget/controllers/widget.get.js

@@ -39,49 +39,49 @@ export default async function widgetGet({ pg = pgClients.client, user = {}, para
     }
     const sqls = {
         comment: pg.pk["admin.users"]
-            ? `select communication_id, entity_id, body, subject, c.cdate, c.uid, 
-    ${username} as username, u.login, u.avatar
-    from crm.communications c
-    left join admin.users u on u.uid=c.uid 
+            ? `select communication_id, entity_id, body, subject, c.cdate, c.uid, 
+    ${username} as username, u.login, u.avatar
+    from crm.communications c
+    left join admin.users u on u.uid=c.uid 
     where entity_id=$1 order by cdate desc`
             : "select communication_id, entity_id, body, subject, cdate, uid from crm.communications where entity_id=$1 order by cdate desc",
-        history: `SELECT change_id, entity_id, entity_type, change_type, change_date, a.change_user_id, a.uid, a.cdate, b.json_agg as changes,
-      ${username} as username, u.login, u.avatar
-      FROM log.table_changes a
-      left join admin.users u on a.change_user_id = u.uid
-      left join lateral(
-        select json_agg(row_to_json(q)) from (
-          select change_data_id, entity_key, value_new, value_old from log.table_changes_data
-          where change_id=a.change_id
-        )q
-      )b on 1=1
-      where a.change_type != 'INSERT' and b.json_agg is not null and (entity_id=$1 or entity_id in (
-        select communication_id from crm.communications where entity_id=$1
-        union all select checklist_id from crm.checklists where entity_id=$1
-        union all select file_id from crm.files where entity_id=$1) 
-      )
+        history: `SELECT change_id, entity_id, entity_type, change_type, change_date, a.change_user_id, a.uid, a.cdate, b.json_agg as changes,
+      ${username} as username, u.login, u.avatar
+      FROM log.table_changes a
+      left join admin.users u on a.change_user_id = u.uid
+      left join lateral(
+        select json_agg(row_to_json(q)) from (
+          select change_data_id, entity_key, value_new, value_old from log.table_changes_data
+          where change_id=a.change_id
+        )q
+      )b on 1=1
+      where a.change_type != 'INSERT' and b.json_agg is not null and (entity_id=$1 or entity_id in (
+        select communication_id from crm.communications where entity_id=$1
+        union all select checklist_id from crm.checklists where entity_id=$1
+        union all select file_id from crm.files where entity_id=$1) 
+      )
       order by cdate desc limit 100`,
         checklist: pg.pk["admin.users"]
-            ? `SELECT checklist_id, entity_id, subject, is_done, done_date, c.uid, c.cdate, ${username} as username, u.login, u.avatar
-      FROM crm.checklists c
-      left join admin.users u on u.uid=c.uid
+            ? `SELECT checklist_id, entity_id, subject, is_done, done_date, c.uid, c.cdate, ${username} as username, u.login, u.avatar
+      FROM crm.checklists c
+      left join admin.users u on u.uid=c.uid
       where entity_id=$1 order by cdate desc`
             : "SELECT checklist_id, entity_id, subject, is_done, done_date, uid, cdate FROM crm.checklists where entity_id=$1 order by cdate desc",
         file: pg.pk["admin.users"]
-            ? `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, c.uid, c.cdate, file_type, c.ismain, 
-    ${username} as username, u.login, isverified, u.avatar, u.uid as author, file_status 
-    FROM crm.files c 
-    left join admin.users u on u.uid=c.uid
+            ? `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, c.uid, c.cdate, file_type, c.ismain, 
+    ${username} as username, u.login, isverified, u.avatar, u.uid as author, file_status 
+    FROM crm.files c 
+    left join admin.users u on u.uid=c.uid
     where entity_id=$1 and file_status<>3 order by cdate desc`
-            : `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, uid, cdate, file_type, ismain,
+            : `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, uid, cdate, file_type, ismain,
       isverified, uid as author, file_status FROM crm.files c where entity_id=$1 and file_status<>3 order by cdate desc`,
         gallery: pg.pk["admin.users"]
-            ? `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, c.uid, c.cdate, file_type, c.ismain,
-    ${username} as username, u.login, u.avatar, isverified, u.avatar, c.uid as author, file_status 
-    FROM crm.files c 
-    left join admin.users u on u.uid=c.uid
+            ? `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, c.uid, c.cdate, file_type, c.ismain,
+    ${username} as username, u.login, u.avatar, isverified, u.avatar, c.uid as author, file_status 
+    FROM crm.files c 
+    left join admin.users u on u.uid=c.uid
     where entity_id=$1 and file_status<>3 and ext = any($2) order by cdate desc`
-            : `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, c.uid, c.cdate, file_type, ismain,
+            : `SELECT file_id, entity_id, entity_type, file_path, uploaded_name, ext, size, c.uid, c.cdate, file_type, ismain,
       isverified, uid as author, file_status FROM crm.files c where entity_id=$1 and file_status<>3 and ext = any($2) order by cdate desc`,
         reaction: "SELECT count(*), reaction_type FROM crm.reactions c where entity_id=$1 group by reaction_type",
     };
@@ -127,7 +127,7 @@ export default async function widgetGet({ pg = pgClients.client, user = {}, para
     }
     const cdateColumn = columns.find((col) => ["cdate", "created_at"].includes(col.name))?.name;
     const editorDateColumn = columns.find((col) => ["editor_date", "updated_at"].includes(col.name))?.name;
-    const q1 = `select ${username} as author, u.login ${cdateColumn ? `,a.${cdateColumn} as cdate` : ""} ${editorDateColumn ? `,a.${editorDateColumn} as editor_date` : ""} from ${tableName} a 
+    const q1 = `select ${username} as author, u.login ${cdateColumn ? `,a.${cdateColumn} as cdate` : ""} ${editorDateColumn ? `,a.${editorDateColumn} as editor_date` : ""} from ${tableName} a 
   left join admin.users u on a.${authorIdColumn}=u.uid where a.${pk}=$1 limit 1`;
     const data = pg.pk["admin.users"] && pk && tableName
         ? await pg