@opengis/fastify-table 2.6.2 → 2.6.4

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.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"suggest.d.ts","sourceRoot":"","sources":["../../../../../server/routes/table/controllers/suggest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAgCpD,wBAAsB,kBAAkB,CAAC,EACvC,KAAK,EACL,QAAQ,EACR,MAAM,EACN,UAAU,EACV,QAAQ,EACR,UAAU,EACV,GAAG,EACH,EAAqB,GACtB,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,UAAU,CAAC;CACjB;;;;;;UAyGA;AAED,wBAA8B,OAAO,CAAC,GAAG,EAAE,GAAG,gBAqe7C"}
+{"version":3,"file":"suggest.d.ts","sourceRoot":"","sources":["../../../../../server/routes/table/controllers/suggest.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AA+BpD,wBAAsB,kBAAkB,CAAC,EACvC,KAAK,EACL,QAAQ,EACR,MAAM,EACN,UAAU,EACV,QAAQ,EACR,UAAU,EACV,GAAG,EACH,EAAqB,GACtB,EAAE;IACD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,GAAG,CAAC;IACZ,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE,GAAG,CAAC;IACf,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,EAAE,CAAC,EAAE,UAAU,CAAC;CACjB;;;;;;UAyGA;AAED,wBAA8B,OAAO,CAAC,GAAG,EAAE,GAAG,gBAif7C"}

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

@@ -13,7 +13,7 @@ export async function getTableColumnMeta({ table, template, column, selectName,
         table,
     }).then((el) => el?.columns || []);
     const { dataTypeID } = (metaColumns || []).find((col) => col?.name === column) || {};
-    const { columns, table: tableName, sql, } = template ? await getTemplate("table", template) : { table, columns: [] };
+    const { columns, table: tableName, sql, } = template ? await getTemplate("table", template) : { sql: [], table, columns: [] };
     const filters = template
         ? await getFilter({ pg, table: template }).then((el) => el.list)
         : null;
@@ -47,13 +47,13 @@ export async function getTableColumnMeta({ table, template, column, selectName,
         : `id in ( with cc(id, text) as (${select}) select id from cc where (lower("text") ~ $1) )`;
     const counts = pg.queryCache
         ? await pg
-            .queryCache(`SELECT json_object_agg(          (
-            SELECT
-              nspname
-            FROM
-              pg_namespace
-            WHERE
-              oid = relnamespace
+            .queryCache(`SELECT json_object_agg(          (
+            SELECT
+              nspname
+            FROM
+              pg_namespace
+            WHERE
+              oid = relnamespace
           ) || '.' || relname, reltuples::bigint) FROM pg_class WHERE relkind = 'r'`)
             .then((r) => r.rows[0].json_object_agg)
         : {};
@@ -83,7 +83,7 @@ export async function getTableColumnMeta({ table, template, column, selectName,
 export default async function suggest(req) {
     const time = Date.now();
     const { params, user, query = {}, pg: pg1 = pgClients.client } = req;
-    const { lang = "ua", parent } = query;
+    const { lang = "ua", parent, page = 0 } = query;
     const debugMode = config.local ||
         user?.user_type?.includes?.("admin") ||
         process.env.NODE_ENV === "test" ||
@@ -258,7 +258,9 @@ export default async function suggest(req) {
             const data2 = data1.filter((el) => el.id === "null"
                 ? vals.includes(null)
                 : el.id && vals.includes(el.id.toString()));
-            const data = data2.slice(0, Math.min(query.limit || limit, limit));
+            const limit1 = Math.min(query.limit || limit, limit);
+            const offset = page && page > 0 ? (page - 1) * limit1 : 0;
+            const data = data2.slice(offset, limit1 + offset);
             if (data.length && query.count) {
                 const counts = qRes.rows?.reduce?.((acc, curr) => ({
                     ...acc,
@@ -280,7 +282,8 @@ export default async function suggest(req) {
             }
             return {
                 time: Date.now() - time,
-                limit: Math.min(query.limit || limit, limit),
+                limit: limit1,
+                offset,
                 count: data.length,
                 total: arr.length,
                 mode: "array",
@@ -298,7 +301,9 @@ export default async function suggest(req) {
                 (el[lang] || el.text)?.toLowerCase()?.indexOf(lower) !== -1)
                 ?.filter((el) => !query.val || query.val?.split?.(",")?.includes?.(el.id))
             : arr;
-        const data = data1.slice(0, Math.min(query.limit || limit, limit));
+        const limit1 = Math.min(query.limit || limit, limit);
+        const offset = page && page > 0 ? (page - 1) * limit1 : 0;
+        const data = data1.slice(offset, limit1 + offset);
         if (config.debug) {
             logger.file("suggest/debug", {
                 type: 2,
@@ -309,11 +314,12 @@ export default async function suggest(req) {
         }
         return {
             time: Date.now() - time,
-            limit: Math.min(query.limit || limit, limit),
+            limit: limit1,
+            offset,
             count: data.length,
             total: arr.length,
             mode: "array",
-            data,
+            data
         };
     }
     const args = [];
@@ -343,15 +349,18 @@ export default async function suggest(req) {
         ? ""
         : "order by 2";
     const whereQuery = where.filter(Boolean).join(" and ") || "true";
-    args.push(Math.min(query.limit || meta.limit || limit, limit));
+    const limit1 = Math.min(query.limit || meta.limit || limit, limit);
+    const offset = page && page > 0 ? (page - 1) * limit1 : 0;
+    args.push(limit1);
+    args.push(offset);
     let sqlSuggest = tableName && column
-        ? `${meta.original}
-          WHERE EXISTS ( SELECT 1 FROM ${tableName} o 
+        ? `${meta.original}
+          WHERE EXISTS ( SELECT 1 FROM ${tableName} o 
             WHERE ${pg.pgType[dataTypeID]?.includes("[]")
             ? `c.id = ANY(o."${column}")`
-            : `o."${column}" IS NOT DISTINCT FROM c.id`} ) and ${whereQuery || "true"}
-          ${order} LIMIT $${args.length}::int`
-        : `with c(id,text) as ( ${meta.original} where ${whereQuery} ${order}) select * from c LIMIT $${args.length}::int`;
+            : `o."${column}" IS NOT DISTINCT FROM c.id`} ) and ${whereQuery || "true"}
+          ${order} LIMIT $${args.length - 1}::int OFFSET $${args.length}::int`
+        : `with c(id,text) as ( ${meta.original} where ${whereQuery} ${order}) select * from c LIMIT $${args.length - 1}::int OFFSET $${args.length}::int`;
     if (sqlSuggest.includes("{{parent}}")) {
         args.push(parent || "");
         sqlSuggest = sqlSuggest.replace(/(['"]?){{parent}}\1/gi, `$${args.length}`);
@@ -385,7 +394,8 @@ export default async function suggest(req) {
         });
         return {
             time: Date.now() - time,
-            limit: Math.min(query.limit || meta.limit || limit, limit),
+            limit: limit1,
+            offset,
             count: data.length,
             total: meta.count - 0,
             mode: type === "cls" ? "array" : "sql",
@@ -418,7 +428,8 @@ export default async function suggest(req) {
     }
     const message = {
         time: Date.now() - time,
-        limit: Math.min(query.limit || meta.limit || limit, limit),
+        limit: limit1,
+        offset,
         count: data.length,
         total: meta.count - 0,
         mode: "sql",

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

@@ -355,9 +355,9 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
         interfaceQuery1,
     ].filter(Boolean);
     const omitGeometry = !objectId && loadTable?.showGeometryMode === "card";
-    const q1 = `select  ${pk ? `"${pk}" as id,` : ""} 
-  ${objectId || query?.key ? "*" : columnsParam || sqlColumns || cols || "*"} 
-  ${metaCols}
+    const q1 = `select  ${pk ? `"${pk}" as id,` : ""} 
+  ${objectId || query?.key ? "*" : columnsParam || sqlColumns || cols || "*"} 
+  ${metaCols}
   ${dbColumns.filter((el) => pg.pgType?.[el.dataTypeID] === "geometry")
         .length &&
         !columnsParam &&
@@ -366,14 +366,14 @@ export default async function dataAPI({ pg = pgClients.client, params, table, id
             .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} limit $${idx.limit}::bigint offset $${idx.offset}::bigint`;
     if (q1.includes("{{uid}}")) {
         args.push(uid || "");
@@ -458,18 +458,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)
         .join(" and ") || "true"} `.replace(/'{{uid}}'/g, `$${idx1.uid}`);

package/dist/server/routes/table/schema.d.ts

@@ -153,6 +153,11 @@ declare const suggestSchema: {
                 minimum: number;
                 maximum: number;
             };
+            page: {
+                type: string;
+                minimum: number;
+                maximum: number;
+            };
             parent: {
                 type: string;
                 pattern: string;

package/dist/server/routes/table/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../server/routes/table/schema.ts"],"names":[],"mappings":"AAKA,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BhB,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAajB,CAAC;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuBlB,CAAC;AAEF,QAAA,MAAM,UAAU;;;;;;;;;;;;;;CAQf,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;CAOjB,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;CAatB,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;CAQtB,CAAC;AAEF,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,UAAU,EACV,YAAY,EACZ,iBAAiB,GAClB,CAAC"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../server/routes/table/schema.ts"],"names":[],"mappings":"AAKA,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBpB,CAAC;AAEF,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BhB,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAajB,CAAC;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAwBlB,CAAC;AAEF,QAAA,MAAM,UAAU;;;;;;;;;;;;;;CAQf,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;CAOjB,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;CAatB,CAAC;AAEF,QAAA,MAAM,iBAAiB;;;;;;;;;;;;;;CAQtB,CAAC;AAEF,OAAO,EACL,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,aAAa,EACb,UAAU,EACV,YAAY,EACZ,iBAAiB,GAClB,CAAC"}

package/dist/server/routes/table/schema.js

@@ -1,6 +1,6 @@
 const keySchema = {
     type: "string",
-    pattern: "^([А-Яа-яҐґЄєІіЇї\\d\\w\\s_.\\-:—!?%@#$,'\"; ]+)$",
+    pattern: "^([А-Яа-яҐґЄєІіЇї\\d\\w\\s_.\\-:—!?№%@#$,'\"; ]+)$",
 };
 const tableDataSchema = {
     type: "object",
@@ -76,6 +76,7 @@ const suggestSchema = {
         properties: {
             lang: { type: "string", pattern: "^([\\w]+)$" },
             limit: { type: "integer", minimum: 1, maximum: 200 },
+            page: { type: "integer", minimum: 1, maximum: 1000 },
             parent: { type: "string", pattern: "^([\\d\\w_.-]+)$" },
             sel: { type: "string", pattern: "^([\\d\\w_.-]+)$" },
             name: { type: "string", pattern: "^([\\d\\w_.-]+)$" },

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

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

@@ -68,9 +68,9 @@ export default async function widgetSet(req, reply) {
             uid: user?.uid,
         });
         if (type === "gallery") {
-            await pg.query(`update crm.files set ismain=true 
-      where entity_id=$1 
-      and file_id=$2 
+            await pg.query(`update crm.files set ismain=true 
+      where entity_id=$1 
+      and file_id=$2 
       and (select count(*) = 0 from crm.files where entity_id=$1 and ismain)`, [objectid, rows[0]?.file_id]);
         }
         return {
@@ -111,7 +111,7 @@ export default async function widgetSet(req, reply) {
         });
     // put w/ out file
     if (type === "gallery" && body?.ismain && id) {
-        await pg.query(`update crm.files set ismain=false 
+        await pg.query(`update crm.files set ismain=false 
         where entity_id=$1 and file_id<>$2`, [objectid, id]);
     }
     return reply.status(200).send({

package/dist/server/routes/widget/services/widget.entity.get.js

@@ -36,49 +36,49 @@ export default async function widgetEntityGet({ type, entityType, objectid, uid,
     }
     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 and entity_type=$2 order by cdate desc`
             : "select communication_id, entity_id, body, subject, cdate, uid from crm.communications where entity_id=$1 and entity_type=$2 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 and entity_type=$2) or entity_id in (
-        select communication_id from crm.communications where entity_id=$1 and entity_type=$2
-        union all select checklist_id from crm.checklists where entity_id=$1 and entity_type=$2
-        union all select file_id from crm.files where entity_id=$1 and entity_type=$2) 
-      )
+        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 and entity_type=$2) or entity_id in (
+        select communication_id from crm.communications where entity_id=$1 and entity_type=$2
+        union all select checklist_id from crm.checklists where entity_id=$1 and entity_type=$2
+        union all select file_id from crm.files where entity_id=$1 and entity_type=$2) 
+      )
       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 and entity_type=$2 order by cdate desc`
             : "SELECT checklist_id, entity_id, subject, is_done, done_date, uid, cdate FROM crm.checklists where entity_id=$1 and entity_type=$2 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 entity_type=$2 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 entity_type=$2 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 entity_type=$2 and file_status<>3 and ext = any($3) 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 entity_type=$2 and file_status<>3 and ext = any($3) order by cdate desc`,
         reaction: "SELECT count(*), reaction_type FROM crm.reactions c where entity_id=$1 and entity_type=$2 group by reaction_type",
     };
@@ -117,7 +117,7 @@ export default async function widgetEntityGet({ type, entityType, objectid, uid,
     }
     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 ${entityType} a 
+    const q1 = `select ${username} as author, u.login ${cdateColumn ? `,a.${cdateColumn} as cdate` : ""} ${editorDateColumn ? `,a.${editorDateColumn} as editor_date` : ""} from ${entityType} a 
   left join admin.users u on a.${authorIdColumn}=u.uid where a.${pk}=$1 limit 1`;
     const data = pg.pk["admin.users"] && pk && entityType
         ? await pg

package/dist/server/routes/widget/services/widget.entity.set.js

@@ -75,9 +75,9 @@ export default async function widgetEntitySet({ type, entityType, objectid, id,
             uid,
         }).then((r) => r.rows?.[0]);
         if (type === "gallery") {
-            await pg.query(`update crm.files set ismain=true 
-      where entity_id=$1 and entity_type=$2
-      and file_id=$3
+            await pg.query(`update crm.files set ismain=true 
+      where entity_id=$1 and entity_type=$2
+      and file_id=$3
       and (select count(*) = 0 from crm.files where entity_id=$1 and entity_type=$2 and ismain)`, [objectid, entityType, row?.file_id]);
         }
         return {
@@ -119,7 +119,7 @@ export default async function widgetEntitySet({ type, entityType, objectid, id,
         });
     // put w/ out file
     if (type === "gallery" && body?.ismain && id) {
-        await pg.query(`update crm.files set ismain=false 
+        await pg.query(`update crm.files set ismain=false 
       where entity_id=$1 and entity_type=$2 and file_id<>$3`, [objectid, entityType, id]);
     }
     return {