@opengis/fastify-table 2.6.2 → 2.6.3

package/dist/server/plugins/sqlite/funcs/init.js

@@ -3,28 +3,28 @@ function init(client) {
     if (!client) {
         return;
     }
-    const rows = client.prepare(`WITH tables AS (
-    SELECT name AS table_name
-    FROM sqlite_master
-    WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
-  ),
-  pk_columns AS (
-    SELECT
-      m.name AS table_name,
-      ti.name AS column_name,
-      ti.pk
-    FROM sqlite_master m
-    JOIN pragma_table_info(m.name) AS ti
-    WHERE ti.pk = 1
-  )
-  SELECT table_name, column_name
-  FROM pk_columns
-  WHERE table_name IN (
-    SELECT table_name
-    FROM pk_columns
-    GROUP BY table_name
-    HAVING COUNT(*) = 1
-  )
+    const rows = client.prepare(`WITH tables AS (
+    SELECT name AS table_name
+    FROM sqlite_master
+    WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+  ),
+  pk_columns AS (
+    SELECT
+      m.name AS table_name,
+      ti.name AS column_name,
+      ti.pk
+    FROM sqlite_master m
+    JOIN pragma_table_info(m.name) AS ti
+    WHERE ti.pk = 1
+  )
+  SELECT table_name, column_name
+  FROM pk_columns
+  WHERE table_name IN (
+    SELECT table_name
+    FROM pk_columns
+    GROUP BY table_name
+    HAVING COUNT(*) = 1
+  )
   ORDER BY table_name;`).all();
     const pk = Object.fromEntries(rows.map((row) => [row.table_name, row.column_name]));
     const tlist = client.prepare('SELECT name FROM sqlite_master WHERE type=\'table\' AND name NOT LIKE \'sqlite_%\';').all().reduce((acc, curr) => {

package/dist/server/plugins/table/funcs/getData.js

@@ -342,9 +342,9 @@ export default async function dataAPI({ table, id, page, limit: queryLimit, sql,
         interfaceQuery1,
     ].filter(Boolean);
     const omitGeometry = omitGeometryParam || (!objectId && loadTable?.showGeometryMode === "card");
-    const q1 = `select  ${pk ? `"${pk}" as id,` : ""} 
-  ${objectId ? "*" : columnsParam || sqlColumns || cols || "*"} 
-  ${metaCols}
+    const q1 = `select  ${pk ? `"${pk}" as id,` : ""} 
+  ${objectId ? "*" : columnsParam || sqlColumns || cols || "*"} 
+  ${metaCols}
   ${dbColumns.filter((el) => pg.pgType?.[el.dataTypeID] === "geometry")
         .length &&
         !columnsParam &&
@@ -353,14 +353,14 @@ export default async function dataAPI({ table, id, page, limit: queryLimit, sql,
             .filter((el) => pg.pgType?.[el.dataTypeID] === "geometry")
             .map((el) => `st_asgeojson("${el.name.replace(/'/g, "''")}")::json as "${el.name.replace(/'/g, "''")}"`)
             .join(",")}`
-        : ""} 
+        : ""} 
   from (select * ${sqlQueryList
         ?.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 || "");
@@ -445,18 +445,18 @@ export default async function dataAPI({ table, id, page, limit: queryLimit, sql,
         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 * ${sqlQueryList
         ?.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/plugins/table/funcs/getFilterSQL/util/getCustomQuery.js

@@ -6,7 +6,7 @@ async function getCustomQuery({ pg, table, customFilter }) {
         ?.map((el) => el?.split("_").pop());
     const customFilterSQL = pg?.pk?.["admin.properties"]
         ? await pg
-            .query(`select json_agg(json_build_object('id',property_id,'name',property_key,'query',property_text)
+            .query(`select json_agg(json_build_object('id',property_id,'name',property_key,'query',property_text)
   ) as property_json from admin.properties where property_key is not null and property_entity='customQuery' and object_id=$1`, [table])
             .then((el) => el.rows?.[0]?.property_json || [])
         : [];

package/dist/server/plugins/table/funcs/getSelect.js

@@ -4,7 +4,7 @@ import getTemplate from "./getTemplate.js";
 const loadCls = {};
 const sqls = {
     sql: "select data from admin.user_cls where name=$1 union all select data from admin.cls where name=$1",
-    json: `select json_agg(json_build_object('id', code, 'text', name, 'icon', icon, 'color', color)) as data from admin.user_cls where parent=$1
+    json: `select json_agg(json_build_object('id', code, 'text', name, 'icon', icon, 'color', color)) as data from admin.user_cls where parent=$1
   union all select json_agg(json_build_object('id', code, 'text', name, 'icon', icon, 'color', color, 'ua', ua, 'en', en)) as data from admin.cls where parent=$1`,
 };
 export default async function getSelect(name, pg = pgClients.client, nocache = false) {

package/dist/server/plugins/table/funcs/gisIRColumn.js

@@ -18,7 +18,7 @@ export default async function gisIRColumn({ pg = pgClients.client, layer, column
         custom,
     });
     const { tlist } = await pg
-        .query(`select array_agg((select nspname from pg_namespace where oid=relnamespace)||'.'||relname) tlist from pg_class 
+        .query(`select array_agg((select nspname from pg_namespace where oid=relnamespace)||'.'||relname) tlist from pg_class 
   where relkind in ('r','v','m')`)
         .then((el) => el.rows?.[0] || {});
     const tableName = body?.table || layer;
@@ -33,9 +33,9 @@ export default async function gisIRColumn({ pg = pgClients.client, layer, column
     const colField = pg.pgType?.[col.dataTypeID]?.includes("[]")
         ? `unnest(${column})`
         : column;
-    const q = `select ${colField} as id, count(*)::int from (
+    const q = `select ${colField} as id, count(*)::int from (
     ${fData?.optimizedSQL ||
-        `select * from ${tableName} where ${body?.query || "true"}`}
+        `select * from ${tableName} where ${body?.query || "true"}`}
   )t group by ${colField} order by count desc limit 15`;
     if (sql)
         return q;

package/dist/server/plugins/usercls/index.js

@@ -162,9 +162,9 @@ export async function getUserClsList({ name, search, sql, custom, }, pg = pgClie
     }
     const whereQuery = where.join(" and ") || "1=1";
     console.log(name, search, whereQuery);
-    const customQuery = `select true as custom, name, type, description, alias, case when type = 'sql' then 1 else (select count(*) from admin.user_cls where parent=t.name limit 1) end as count 
+    const customQuery = `select true as custom, name, type, description, alias, case when type = 'sql' then 1 else (select count(*) from admin.user_cls where parent=t.name limit 1) end as count 
   from admin.user_cls t where parent is null and ${whereQuery}`;
-    const gitQuery = `select false as custom, name, type, null as description, null as alias, case when type = 'sql' then 1 else (select count(*) from admin.cls where parent=t.name limit 1) end as count 
+    const gitQuery = `select false as custom, name, type, null as description, null as alias, case when type = 'sql' then 1 else (select count(*) from admin.cls where parent=t.name limit 1) end as count 
   from admin.cls t where parent is null and ${whereQuery.replace(/admin.user_cls/g, "admin.cls")}`;
     const q = [
         custom !== "0" ? customQuery : null,

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

@@ -12,18 +12,18 @@ export default async function accessGroup({ pg = pgClients.client, params, user
         throw ForbiddenError("not an admin");
     }
     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.role_id=$1`, [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 role_id=$1`, [params.id])
         .then((el) => el.rows || []);
     const users = 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.role_id=$1`, [params.id])
         .then((el) => el.rows || []);
     return { routes, resources, users };

package/dist/server/routes/access/controllers/access.group.post.js

@@ -39,12 +39,12 @@ export default async function accessGroupPost({ pg = pgClients.client, params, u
                 .filter((el) => el.resource && el.actions)
                 .map((el) => pg.query("insert into admin.role_access(role_id,resource_id,route_id,actions)   values ($1,$2,$3,$4)", [id, el.resource, el.path, el.actions])));
             const rows = await pg
-                .query(`select a.route_id as path, b.actions as 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 as actions from admin.routes a 
+              left join admin.role_access b on a.route_id=b.route_id
               where b.role_id=$1`, [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 role_id=$1`, [id])
                 .then((el) => el.rows || []);
             if (!users?.length) {

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

@@ -1,19 +1,19 @@
 import { ForbiddenError, UnauthorizedError } from "../../../../errors.js";
 import { pgClients, metaFormat } 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) {
     const { pg = pgClients.client, params = {}, user = {} } = req;

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

@@ -13,18 +13,18 @@ export default async function accessUser({ pg = pgClients.client, params, user,
         // throw ForbiddenError("not an admin");
     }
     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`, [params.id])
         .then((r) => r.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`, [params.id])
         .then((r) => r.rows || []);
     const userRoles = 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`, [params.id])
         .then((r) => r.rows?.[0]);
     return { routes, resources, user: userRoles };

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

@@ -24,20 +24,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((r) => r.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((r) => r.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, `../../../../../dist/server/templates/pt/${template}.hbs`), "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/crud/functions/deleteTableRelation.js

@@ -43,15 +43,15 @@ export default async function deleteTableRelation({ table: paramsTable, id: para
     }
     const relationTableTemplate = await getTemplate("table", relationTable);
     const pks = await pg
-        .query(`
-    SELECT
-      connamespace::regnamespace::text,
-      conrelid::regclass,
-      (
-        SELECT attname FROM pg_attribute WHERE attrelid = c.conrelid AND attnum = c.conkey[1]
-      ) as pk
-    FROM pg_constraint c
-    WHERE contype = 'p'
+        .query(`
+    SELECT
+      connamespace::regnamespace::text,
+      conrelid::regclass,
+      (
+        SELECT attname FROM pg_attribute WHERE attrelid = c.conrelid AND attnum = c.conkey[1]
+      ) as pk
+    FROM pg_constraint c
+    WHERE contype = 'p'
     AND connamespace::regnamespace::text NOT IN ('sde')`)
         .then((r) => r.rows || []);
     const pkList = pks.reduce((acc, curr) => ({

package/dist/server/routes/crud/functions/updateTableRelation.js

@@ -49,15 +49,15 @@ export default async function updateTableRelation({ table: paramsTable, id: para
         throw new Error("invalid relation: foreignKey not set");
     }
     const pks = await pg
-        .query(`
-    SELECT
-      connamespace::regnamespace::text,
-      conrelid::regclass,
-      (
-        SELECT attname FROM pg_attribute WHERE attrelid = c.conrelid AND attnum = c.conkey[1]
-      ) as pk
-    FROM pg_constraint c
-    WHERE contype = 'p'
+        .query(`
+    SELECT
+      connamespace::regnamespace::text,
+      conrelid::regclass,
+      (
+        SELECT attname FROM pg_attribute WHERE attrelid = c.conrelid AND attnum = c.conkey[1]
+      ) as pk
+    FROM pg_constraint c
+    WHERE contype = 'p'
     AND connamespace::regnamespace::text NOT IN ('sde')`)
         .then((r) => r.rows || []);
     const pkList = pks.reduce((acc, curr) => ({

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,10 +79,10 @@ 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=$3" : "1=1"} 
-  and resized is null
+    const q = `select file_id as id, file_path as relpath from crm.files
+  where ext=any($1)
+  and ${filepath ? "file_path=$3" : "1=1"} 
+  and resized is null
   limit $2`;
     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::bigint offset $3::bigint`;
 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;