prostgles-server 4.2.187 → 4.2.189

package/lib/DboBuilder/runSQL.ts

@@ -1,14 +1,6 @@
-import pgPromise, {
-  ParameterizedQuery as PQ,
-  ParameterizedQuery,
-} from "pg-promise";
+import pgPromise, { ParameterizedQuery as PQ, ParameterizedQuery } from "pg-promise";
 import pg from "pg-promise/typescript/pg-subset";
-import {
-  AnyObject,
-  SQLOptions,
-  SQLResult,
-  SQLResultInfo,
-} from "prostgles-types";
+import { AnyObject, SQLOptions, SQLResult, SQLResultInfo } from "prostgles-types";
 import { DB, Prostgles } from "../Prostgles";
 import { DboBuilder, LocalParams, pgp, postgresToTsType } from "./DboBuilder";
 
@@ -17,18 +9,16 @@ export async function runSQL(
   queryWithoutRLS: string,
   args: undefined | AnyObject | any[],
   options: SQLOptions | undefined,
-  localParams?: LocalParams,
+  localParams?: LocalParams
 ) {
   const queryWithRLS = queryWithoutRLS;
   if (
     queryWithRLS
-      ?.replace(/\s\s+/g, " ")
+      .replace(/\s\s+/g, " ")
       .toLowerCase()
       .includes("create extension pg_stat_statements")
   ) {
-    const { shared_preload_libraries } = await this.db.oneOrNone(
-      "SHOW shared_preload_libraries",
-    );
+    const { shared_preload_libraries } = await this.db.oneOrNone("SHOW shared_preload_libraries");
     if (!(shared_preload_libraries || "").includes("pg_stat_statements")) {
       throw (
         "This query will crash the server (pg_stat_statements must be loaded via shared_preload_libraries). Need to: \n ALTER SYSTEM SET shared_preload_libraries = 'pg_stat_statements' \n" +
@@ -43,11 +33,7 @@ export async function runSQL(
     throw "Not allowed to run SQL";
   }
 
-  const {
-    returnType,
-    allowListen,
-    hasParams = true,
-  }: SQLOptions = options || ({} as SQLOptions);
+  const { returnType, allowListen, hasParams = true }: SQLOptions = options || ({} as SQLOptions);
   const { socket } = localParams || {};
 
   const db = localParams?.tx?.t || this.db;
@@ -71,16 +57,10 @@ export async function runSQL(
     }
   }
 
-  if (!db) {
-    throw "db is missing";
-  }
-
   let finalQuery: string | ParameterizedQuery = queryWithRLS + "";
   const isNotListenOrNotify =
     returnType === "arrayMode" &&
-    !["listen ", "notify "].find((c) =>
-      queryWithoutRLS.toLowerCase().trim().startsWith(c),
-    );
+    !["listen ", "notify "].find((c) => queryWithoutRLS.toLowerCase().trim().startsWith(c));
   if (isNotListenOrNotify) {
     finalQuery = new PQ({
       rowMode: "array",
@@ -92,16 +72,10 @@ export async function runSQL(
   let queryResult: pgPromise.IResultExt<AnyObject> | undefined;
 
   if (returnType === "default-with-rollback") {
-    const ROLLBACK = "Rollback";
-    await db
-      .tx(async (t) => {
-        queryResult = await t.result<AnyObject>(finalQuery, params);
-        /** Rollback */
-        return Promise.reject(new Error(ROLLBACK));
-      })
-      .catch((e) => {
-        if (!(e instanceof Error && e.message === ROLLBACK)) throw e;
-      });
+    await db.tx(async (t) => {
+      queryResult = await t.result<AnyObject>(finalQuery, params);
+      await t.none("ROLLBACK");
+    });
   } else {
     queryResult = await db.result<AnyObject>(finalQuery, params);
   }
@@ -112,7 +86,7 @@ export async function runSQL(
     queryWithoutRLS,
     queryResult,
     allowListen,
-    localParams,
+    localParams
   );
   if (listenHandlers) {
     return listenHandlers;
@@ -123,9 +97,9 @@ export async function runSQL(
   } else if (returnType === "row") {
     return rows[0];
   } else if (returnType === "value") {
-    return Object.values(rows?.[0] ?? {})?.[0];
+    return Object.values(rows[0] ?? {})[0];
   } else if (returnType === "values") {
-    return rows.map((r) => Object.values(r ?? {})[0]);
+    return rows.map((r) => Object.values(r)[0]);
   } else {
     const qres: SQLResult<typeof returnType> = {
       duration: 0,
@@ -141,7 +115,7 @@ const onSQLResult = async function (
   queryWithoutRLS: string,
   { command }: Omit<SQLResultInfo, "duration">,
   allowListen: boolean | undefined,
-  localParams?: LocalParams,
+  localParams?: LocalParams
 ) {
   this.prostgles.schemaWatch?.onSchemaChangeFallback?.({
     command,
@@ -152,13 +126,10 @@ const onSQLResult = async function (
     const { socket } = localParams || {};
     if (!allowListen)
       throw new Error(
-        `Your query contains a LISTEN command. Set { allowListen: true } to get subscription hooks. Or ignore this message`,
+        `Your query contains a LISTEN command. Set { allowListen: true } to get subscription hooks. Or ignore this message`
       );
     if (!socket) throw "Only allowed with client socket";
-    return await this.prostgles.dbEventsManager?.addNotify(
-      queryWithoutRLS,
-      socket,
-    );
+    return await this.prostgles.dbEventsManager?.addNotify(queryWithoutRLS, socket);
   }
 };
 
@@ -168,10 +139,8 @@ export async function cacheDBTypes(this: DboBuilder, force = false) {
     this.USER_TABLES = undefined;
     this.USER_TABLE_COLUMNS = undefined;
   }
-  this.DATA_TYPES ??=
-    (await this.db.any("SELECT oid, typname FROM pg_type")) ?? [];
-  this.USER_TABLES ??=
-    (await this.db.any(`
+  this.DATA_TYPES ??= await this.db.any("SELECT oid, typname FROM pg_type");
+  this.USER_TABLES ??= await this.db.any(`
     SELECT 
       relid, 
       relname, 
@@ -187,7 +156,7 @@ export async function cacheDBTypes(this: DboBuilder, force = false) {
     ) c
     ON t.relid = c.table_oid
     GROUP BY relid, relname, schemaname
-  `)) ?? [];
+  `);
   this.USER_TABLE_COLUMNS ??= await this.db.any(`
     SELECT t.relid, t.schemaname,t.relname, c.column_name, c.udt_name, c.ordinal_position
     FROM information_schema.columns c
@@ -197,35 +166,31 @@ export async function cacheDBTypes(this: DboBuilder, force = false) {
 }
 
 export function getDetailedFieldInfo(this: DboBuilder, fields: pg.IColumn[]) {
-  return (
-    fields?.map((f) => {
-      const dataType =
-          this.DATA_TYPES!.find((dt) => +dt.oid === +f.dataTypeID)?.typname ??
-          "text",
-        table = this.USER_TABLES!.find((t) => +t.relid === +f.tableID),
-        column = this.USER_TABLE_COLUMNS!.find(
-          (c) => +c.relid === +f.tableID && c.ordinal_position === f.columnID,
-        ),
-        tsDataType = postgresToTsType(dataType);
-
-      return {
-        ...f,
-        tsDataType,
-        dataType,
-        udt_name: dataType,
-        tableName: table?.relname,
-        tableSchema: table?.schemaname,
-        columnName: column?.column_name,
-      };
-    }) ?? []
-  );
+  return fields.map((f) => {
+    const dataType = this.DATA_TYPES!.find((dt) => +dt.oid === +f.dataTypeID)?.typname ?? "text",
+      table = this.USER_TABLES!.find((t) => +t.relid === +f.tableID),
+      column = this.USER_TABLE_COLUMNS!.find(
+        (c) => +c.relid === +f.tableID && c.ordinal_position === f.columnID
+      ),
+      tsDataType = postgresToTsType(dataType);
+
+    return {
+      ...f,
+      tsDataType,
+      dataType,
+      udt_name: dataType,
+      tableName: table?.relname,
+      tableSchema: table?.schemaname,
+      columnName: column?.column_name,
+    };
+  });
 }
 
 export const canRunSQL = async (
   prostgles: Prostgles,
-  localParams?: LocalParams,
+  localParams?: LocalParams
 ): Promise<boolean> => {
-  if (!localParams?.socket || !localParams?.httpReq) return true;
+  if (!localParams?.socket || !localParams.httpReq) return true;
 
   const { socket } = localParams;
   const publishParams = await prostgles.publishParser!.getPublishParams({
@@ -239,5 +204,5 @@ export const canRunSQL = async (
 export const canCreateTables = async (db: DB): Promise<boolean> => {
   return db
     .any(`SELECT has_database_privilege(current_database(), 'create') as yes`)
-    .then((rows) => rows?.[0].yes === true);
+    .then((rows) => rows[0].yes === true);
 };

package/lib/DboBuilder/uploadFile.ts

@@ -3,14 +3,14 @@ import { LocalParams, Media } from "./DboBuilder";
 import { ValidateRowBasic } from "../PublishParser/PublishParser";
 import { TableHandler } from "./TableHandler/TableHandler";
 
-export const isFile = (row: AnyObject) => {
+export const isFile = (row: any) => {
   return Boolean(
     row &&
       isObject(row) &&
       getKeys(row).sort().join() === ["name", "data"].sort().join() &&
       row.data &&
       (typeof row.data === "string" || Buffer.isBuffer(row.data)) &&
-      typeof row.name === "string",
+      typeof row.name === "string"
   );
 };
 
@@ -26,9 +26,9 @@ type UploadFileArgs = {
 
 export async function uploadFile(
   this: TableHandler,
-  { row, localParams, validate, mediaId }: UploadFileArgs,
+  { row, localParams, validate, mediaId }: UploadFileArgs
 ): Promise<Media> {
-  if (!this.dboBuilder.prostgles?.fileManager) throw "fileManager not set up";
+  if (!this.dboBuilder.prostgles.fileManager) throw "fileManager not set up";
 
   if (!isFile(row))
     throw (
@@ -39,26 +39,16 @@ export async function uploadFile(
     );
   const { data, name } = row;
 
-  const media_id =
-    mediaId ??
-    (await this.db.oneOrNone("SELECT gen_random_uuid() as name")).name;
+  const media_id = mediaId ?? (await this.db.oneOrNone("SELECT gen_random_uuid() as name")).name;
   const nestedInsert = localParams?.nestedInsert;
-  const type = await this.dboBuilder.prostgles.fileManager.getValidatedFileType(
-    {
-      file: data,
-      fileName: name,
-      tableName: nestedInsert?.previousTable,
-      colName: nestedInsert?.referencingColumn,
-    },
-  );
+  const type = await this.dboBuilder.prostgles.fileManager.getValidatedFileType({
+    file: data,
+    fileName: name,
+    tableName: nestedInsert?.previousTable,
+    colName: nestedInsert?.referencingColumn,
+  });
   const media_name = `${media_id}.${type.ext}`;
-  const parsedMediaKeys = [
-    "id",
-    "name",
-    "original_name",
-    "extension",
-    "content_type",
-  ] as const;
+  const parsedMediaKeys = ["id", "name", "original_name", "extension", "content_type"] as const;
   const media: Required<Pick<Media, (typeof parsedMediaKeys)[number]>> = {
     id: media_id,
     name: media_name,
@@ -80,21 +70,20 @@ export async function uploadFile(
     }
   }
 
-  const _media: Media =
-    await this.dboBuilder.prostgles.fileManager.uploadAsMedia({
-      item: {
-        data,
-        name: media.name ?? "????",
-        content_type: media.content_type as any,
-        extension: media.extension,
-      },
-      // imageCompression: {
-      //     inside: {
-      //         width: 1100,
-      //         height: 630
-      //     }
-      // }
-    });
+  const _media: Media = await this.dboBuilder.prostgles.fileManager.uploadAsMedia({
+    item: {
+      data,
+      name: media.name,
+      content_type: media.content_type as any,
+      extension: media.extension,
+    },
+    // imageCompression: {
+    //     inside: {
+    //         width: 1100,
+    //         height: 630
+    //     }
+    // }
+  });
 
   const mediaRow = {
     ...media,

package/lib/FileManager/FileManager.ts

@@ -23,10 +23,7 @@ import { ExpressApp } from "../RestApi";
 
 export const HOUR = 3600 * 1000;
 
-export const asSQLIdentifier = async (
-  name: string,
-  db: DB,
-): Promise<string> => {
+export const asSQLIdentifier = async (name: string, db: DB): Promise<string> => {
   return (await db.one("select format('%I', $1) as name", [name]))?.name;
 };
 
@@ -54,9 +51,7 @@ export type FileUploadArgs = {
   contentType: string;
   file: string | Buffer | stream.PassThrough;
   onFinish: (
-    ...args:
-      | [error: Error, result: undefined]
-      | [error: undefined, result: UploadedCloudFile]
+    ...args: [error: Error, result: undefined] | [error: undefined, result: UploadedCloudFile]
   ) => void;
   onProgress?: (bytesUploaded: number) => void;
 };
@@ -64,10 +59,7 @@ export type CloudClient = {
   upload: (file: FileUploadArgs) => Promise<void>;
   downloadAsStream: (name: string) => Promise<stream.Readable>;
   delete: (fileName: string) => Promise<void>;
-  getSignedUrlForDownload: (
-    fileName: string,
-    expiresInSeconds: number,
-  ) => Promise<string>;
+  getSignedUrlForDownload: (fileName: string, expiresInSeconds: number) => Promise<string>;
 };
 
 export type LocalConfig = {
@@ -161,14 +153,11 @@ export class FileManager {
             }
           } else {
             console.error(
-              "FileManager checkInterval delayedDelete FAIL: Could not access file table tableHandler.delete()",
+              "FileManager checkInterval delayedDelete FAIL: Could not access file table tableHandler.delete()"
             );
           }
         },
-        Math.max(
-          10000,
-          (fullConfig.delayedDelete.checkIntervalHours || 0) * HOUR,
-        ),
+        Math.max(10000, (fullConfig.delayedDelete.checkIntervalHours || 0) * HOUR)
       );
     }
   }
@@ -187,7 +176,7 @@ export class FileManager {
 
   async deleteFile(name: string) {
     if (this.cloudClient) {
-      const res = await this.cloudClient?.delete(name);
+      const res = await this.cloudClient.delete(name);
       return res;
     } else if ("localFolderPath" in this.config) {
       const path = `${this.config.localFolderPath}/${name}`;
@@ -202,8 +191,7 @@ export class FileManager {
 
   getValidatedFileType = getValidatedFileType.bind(this);
 
-  getLocalFileUrl = (name: string) =>
-    this.fileRoute ? `${this.fileRoute}/${name}` : "";
+  getLocalFileUrl = (name: string) => (this.fileRoute ? `${this.fileRoute}/${name}` : "");
 
   checkFreeSpace = async (folderPath: string, fileSize = 0) => {
     if (!this.cloudClient && "localFolderPath" in this.config) {
@@ -229,8 +217,9 @@ export class FileManager {
     dissallowedExtensions?: Array<ALLOWED_EXTENSION>;
     imageOptions?: ImageOptions;
   }): Promise<UploadedItem> => {
-    const { item, imageOptions } = params;
-    const { name, data, content_type, extension } = item;
+    const { item } = params;
+    const { name, data, content_type } = item;
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
     if (!data) throw "No file provided";
     if (!name || typeof name !== "string") throw "Expecting a string name";
 
@@ -280,32 +269,24 @@ export class FileManager {
     return res;
   };
 
-  async getFileCloudDownloadURL(
-    fileName: string,
-    expiresInSecondsRaw: number = 30 * 60,
-  ) {
+  async getFileCloudDownloadURL(fileName: string, expiresInSecondsRaw: number = 30 * 60) {
     const expiresInSeconds = Math.max(1, Math.round(expiresInSecondsRaw));
-    return await this.cloudClient?.getSignedUrlForDownload(
-      fileName,
-      expiresInSeconds,
-    );
+    return await this.cloudClient?.getSignedUrlForDownload(fileName, expiresInSeconds);
   }
 
-  parseSQLIdentifier = async (name: string) =>
-    asSQLIdentifier(name, this.prostgles!.db!); //  this.prostgles.dbo.sql<"value">("select format('%I', $1)", [name], { returnType: "value" } )
+  parseSQLIdentifier = async (name: string) => asSQLIdentifier(name, this.prostgles!.db!); //  this.prostgles.dbo.sql<"value">("select format('%I', $1)", [name], { returnType: "value" } )
 
   getColInfo = (args: {
     tableName: string;
     colName: string;
   }): ValidatedColumnInfo["file"] | undefined => {
     const { colName, tableName } = args;
-    const tableConfig =
-      this.prostgles?.opts.fileTable?.referencedTables?.[tableName];
+    const tableConfig = this.prostgles?.opts.fileTable?.referencedTables?.[tableName];
     const isReferencingFileTable = this.dbo[tableName]?.columns?.some(
       (c) =>
         c.name === colName &&
         c.references &&
-        c.references?.some(({ ftable }) => ftable === this.tableName),
+        c.references.some(({ ftable }) => ftable === this.tableName)
     );
     const allowAllFiles = { acceptedContent: "*" } as const;
     if (isReferencingFileTable) {
@@ -320,15 +301,13 @@ export class FileManager {
   init = initFileManager.bind(this);
 
   destroy = () => {
-    removeExpressRoute(this.prostgles?.opts.fileTable?.expressApp, [
-      this.fileRouteExpress,
-    ]);
+    removeExpressRoute(this.prostgles?.opts.fileTable?.expressApp, [this.fileRouteExpress]);
   };
 }
 
 export const removeExpressRoute = (
   app: ExpressApp | undefined,
-  routePaths: (string | undefined)[],
+  routePaths: (string | undefined)[]
 ) => {
   const routes = app?._router?.stack;
   if (routes) {
@@ -340,10 +319,7 @@ export const removeExpressRoute = (
   }
 };
 
-export const removeExpressRouteByName = (
-  app: ExpressApp | undefined,
-  name: string,
-) => {
+export const removeExpressRouteByName = (app: ExpressApp | undefined, name: string) => {
   const routes = app?._router?.stack;
   if (routes) {
     routes.forEach((route, i) => {
@@ -355,17 +331,15 @@ export const removeExpressRouteByName = (
 };
 
 export const getFileTypeFromFilename = (
-  fileName: string,
-):
-  | { mime: ALLOWED_CONTENT_TYPE; ext: ALLOWED_EXTENSION | string }
-  | undefined => {
+  fileName: string
+): { mime: ALLOWED_CONTENT_TYPE; ext: ALLOWED_EXTENSION | string } | undefined => {
   const nameParts = fileName.split(".");
 
   if (nameParts.length < 2) return undefined;
 
   const nameExt = nameParts.at(-1)!.toLowerCase(),
     mime = getKeys(CONTENT_TYPE_TO_EXT).find((k) =>
-      (CONTENT_TYPE_TO_EXT[k] as readonly string[]).includes(nameExt),
+      (CONTENT_TYPE_TO_EXT[k] as readonly string[]).includes(nameExt)
     );
 
   if (!mime) return undefined;
@@ -381,7 +355,7 @@ export const getFileTypeFromFilename = (
 
 export const getFileType = async (
   file: Buffer | string,
-  fileName: string,
+  fileName: string
 ): Promise<{ mime: ALLOWED_CONTENT_TYPE; ext: ALLOWED_EXTENSION }> => {
   const { fileTypeFromBuffer } = await (eval('import("file-type")') as Promise<
     typeof import("file-type")
@@ -389,25 +363,20 @@ export const getFileType = async (
 
   const fileNameMime = getFileTypeFromFilename(fileName);
   if (!fileNameMime?.ext) throw new Error("File name must contain extenion");
-  const res = await fileTypeFromBuffer(
-    typeof file === "string" ? Buffer.from(file, "utf8") : file,
-  );
+  const res = await fileTypeFromBuffer(typeof file === "string" ? Buffer.from(file, "utf8") : file);
 
   if (!res) {
     /* Set correct/missing extension */
-    const nameExt = fileNameMime?.ext;
-    if (
-      ["xml", "txt", "csv", "tsv", "svg", "sql"].includes(nameExt) &&
-      fileNameMime.mime
-    ) {
+    const nameExt = fileNameMime.ext;
+    if (["xml", "txt", "csv", "tsv", "svg", "sql"].includes(nameExt)) {
       return fileNameMime as any;
     }
 
     throw new Error("Could not get the file type from file buffer");
   } else {
-    if (!res.ext || fileNameMime?.ext.toLowerCase() !== res.ext.toLowerCase()) {
+    if (fileNameMime.ext.toLowerCase() !== res.ext.toLowerCase()) {
       throw new Error(
-        `There is a mismatch between file name extension and actual buffer extension: ${fileNameMime?.ext} vs ${res.ext}`,
+        `There is a mismatch between file name extension and actual buffer extension: ${fileNameMime.ext} vs ${res.ext}`
       );
     }
   }