prostgles-server 4.2.183 → 4.2.185

package/lib/TableConfig/getColumnDefinitionQuery.ts

@@ -1,71 +1,81 @@
-import { asName, pickKeys } from "prostgles-types"; 
+import { asName, pickKeys } from "prostgles-types";
 import { DB } from "../Prostgles";
 import { asValue } from "../PubSubManager/PubSubManager";
 import { VALIDATE_SCHEMA_FUNCNAME } from "../JSONBValidation/validate_jsonb_schema_sql";
 import { BaseColumnTypes, ColumnConfig } from "./TableConfig";
-import pgPromise from "pg-promise"; 
+import pgPromise from "pg-promise";
 
 type Args = {
-  column: string; 
+  column: string;
   colConf: ColumnConfig;
-  db: DB; 
+  db: DB;
   table: string;
 };
 
 /**
  * Column create statement for a given config
  */
-export const getColumnDefinitionQuery = async ({ colConf: colConfRaw, column, db, table }: Args): Promise<string | undefined> => {
-  const colConf = typeof colConfRaw === "string"? { sqlDefinition: colConfRaw } : colConfRaw;
+export const getColumnDefinitionQuery = async ({
+  colConf: colConfRaw,
+  column,
+  db,
+  table,
+}: Args): Promise<string | undefined> => {
+  const colConf =
+    typeof colConfRaw === "string" ? { sqlDefinition: colConfRaw } : colConfRaw;
   const colNameEsc = asName(column);
-  const getColTypeDef = (colConf: BaseColumnTypes, pgType: "TEXT" | "JSONB") => {
+  const getColTypeDef = (
+    colConf: BaseColumnTypes,
+    pgType: "TEXT" | "JSONB",
+  ) => {
     const { nullable, defaultValue } = colConf;
-    return `${pgType} ${!nullable ? " NOT NULL " : ""} ${defaultValue ? ` DEFAULT ${asValue(defaultValue)} ` : ""}`
-  }
+    return `${pgType} ${!nullable ? " NOT NULL " : ""} ${defaultValue ? ` DEFAULT ${asValue(defaultValue)} ` : ""}`;
+  };
 
   const jsonbSchema =
-      ("jsonbSchema" in colConf && colConf.jsonbSchema) ? { jsonbSchema: colConf.jsonbSchema, jsonbSchemaType: undefined } :
-        ("jsonbSchemaType" in colConf && colConf.jsonbSchemaType) ? { jsonbSchema: undefined, jsonbSchemaType: colConf.jsonbSchemaType } :
-          undefined; 
-  
+    "jsonbSchema" in colConf && colConf.jsonbSchema
+      ? { jsonbSchema: colConf.jsonbSchema, jsonbSchemaType: undefined }
+      : "jsonbSchemaType" in colConf && colConf.jsonbSchemaType
+        ? { jsonbSchema: undefined, jsonbSchemaType: colConf.jsonbSchemaType }
+        : undefined;
 
   if ("references" in colConf && colConf.references) {
-
-    const { tableName: lookupTable, columnName: lookupCol = "id" } = colConf.references;
+    const { tableName: lookupTable, columnName: lookupCol = "id" } =
+      colConf.references;
     return ` ${colNameEsc} ${getColTypeDef(colConf.references, "TEXT")} REFERENCES ${lookupTable} (${lookupCol}) `;
-
   } else if ("sqlDefinition" in colConf && colConf.sqlDefinition) {
-
     return ` ${colNameEsc} ${colConf.sqlDefinition} `;
-
   } else if ("isText" in colConf && colConf.isText) {
     let checks = "";
     const colChecks: string[] = [];
     if (colConf.lowerCased) {
-      colChecks.push(`${colNameEsc} = LOWER(${colNameEsc})`)
+      colChecks.push(`${colNameEsc} = LOWER(${colNameEsc})`);
     }
     if (colConf.trimmed) {
-      colChecks.push(`${colNameEsc} = BTRIM(${colNameEsc})`)
+      colChecks.push(`${colNameEsc} = BTRIM(${colNameEsc})`);
     }
     if (colChecks.length) {
-      checks = `CHECK (${colChecks.join(" AND ")})`
+      checks = `CHECK (${colChecks.join(" AND ")})`;
     }
     return ` ${colNameEsc} ${getColTypeDef(colConf, "TEXT")} ${checks}`;
-
   } else if (jsonbSchema) {
-
-    const jsonbSchemaStr = asValue({
-      ...pickKeys(colConf, ["enum", "nullable", "info"]),
-      ...(jsonbSchema.jsonbSchemaType ? { type: jsonbSchema.jsonbSchemaType } : jsonbSchema.jsonbSchema)
-    }) + "::TEXT";
+    const jsonbSchemaStr =
+      asValue({
+        ...pickKeys(colConf, ["enum", "nullable", "info"]),
+        ...(jsonbSchema.jsonbSchemaType
+          ? { type: jsonbSchema.jsonbSchemaType }
+          : jsonbSchema.jsonbSchema),
+      }) + "::TEXT";
 
     /** Validate default value against jsonbSchema  */
     const validationQuery = `SELECT ${VALIDATE_SCHEMA_FUNCNAME}(${jsonbSchemaStr}, ${asValue(colConf.defaultValue) + "::JSONB"}, ${asValue({ table, column })}) as v`;
     if (colConf.defaultValue) {
-
       const failedDefault = (err?: any) => {
-        return { msg: `Default value (${colConf.defaultValue}) for ${table}.${column} does not satisfy the jsonb constraint check: ${validationQuery}`, err };
-      }
+        return {
+          msg: `Default value (${colConf.defaultValue}) for ${table}.${column} does not satisfy the jsonb constraint check: ${validationQuery}`,
+          err,
+        };
+      };
       try {
         const row = await db.oneOrNone(validationQuery);
         if (!row?.v) {
@@ -74,38 +84,49 @@ export const getColumnDefinitionQuery = async ({ colConf: colConfRaw, column, db
       } catch (e) {
         throw failedDefault(e);
       }
-    } 
+    }
 
     return ` ${colNameEsc} ${getColTypeDef(colConf, "JSONB")} CHECK(${VALIDATE_SCHEMA_FUNCNAME}(${jsonbSchemaStr}, ${colNameEsc}, ${asValue({ table, column })} ))`;
-
   } else if ("enum" in colConf) {
-    if (!colConf.enum?.length) throw new Error("colConf.enum Must not be empty");
-    const type = colConf.enum.every(v => Number.isFinite(v)) ? "NUMERIC" : "TEXT";
-    const checks = colConf.enum.map(v => `${colNameEsc} = ${asValue(v)}`).join(" OR ");
+    if (!colConf.enum?.length)
+      throw new Error("colConf.enum Must not be empty");
+    const type = colConf.enum.every((v) => Number.isFinite(v))
+      ? "NUMERIC"
+      : "TEXT";
+    const checks = colConf.enum
+      .map((v) => `${colNameEsc} = ${asValue(v)}`)
+      .join(" OR ");
     return ` ${colNameEsc} ${type} ${colConf.nullable ? "" : "NOT NULL"} ${"defaultValue" in colConf ? ` DEFAULT ${asValue(colConf.defaultValue)}` : ""} CHECK(${checks})`;
-
   } else {
     return undefined;
     // throw "Unknown column config: " + JSON.stringify(colConf);
   }
-}
-
+};
 
-export type ColumnMinimalInfo = { 
+export type ColumnMinimalInfo = {
   table_name: string;
   table_schema: string;
   column_name: string;
   column_default: string | null;
   udt_name: string;
-  nullable: boolean; 
+  nullable: boolean;
 };
-export const getTableColumns = ({ db, table }: { db: DB | pgPromise.ITask<{}>; table: string;}): Promise<ColumnMinimalInfo[]> => {
-  return db.manyOrNone(`
+export const getTableColumns = ({
+  db,
+  table,
+}: {
+  db: DB | pgPromise.ITask<{}>;
+  table: string;
+}): Promise<ColumnMinimalInfo[]> => {
+  return db.manyOrNone(
+    `
     SELECT table_name, 
       table_schema, column_name, 
       column_default, udt_name,
       is_nullable = 'YES' as nullable
     FROM information_schema.columns
     WHERE table_name = $1
-  `, [table]);
-}
+  `,
+    [table],
+  );
+};

package/lib/TableConfig/getConstraintDefinitionQueries.ts

@@ -6,48 +6,55 @@ import { TableConfig } from "./TableConfig";
 
 type Args = {
   tableName: string;
-  tableConf: TableConfig[string]
+  tableConf: TableConfig[string];
   // tableConf: BaseTableDefinition<LANG_IDS> & (TableDefinition<LANG_IDS> | LookupTableDefinition<LANG_IDS>)
 };
 
-export type ConstraintDef = {  
+export type ConstraintDef = {
   /**
    * Named constraints are used to show a relevant error message
    */
-  name?: string; 
-  content: string; 
-  alterQuery: string; 
+  name?: string;
+  content: string;
+  alterQuery: string;
 };
-export const getConstraintDefinitionQueries = ({ tableConf, tableName }: Args): ConstraintDef[] | undefined => {
-
+export const getConstraintDefinitionQueries = ({
+  tableConf,
+  tableName,
+}: Args): ConstraintDef[] | undefined => {
   if ("constraints" in tableConf && tableConf.constraints) {
     const { constraints } = tableConf;
-    if(!constraints){
+    if (!constraints) {
       return undefined;
     }
-    
-    if(Array.isArray(constraints)) {
-      return constraints.map(c => ({ content: c, alterQuery: `ALTER TABLE ${asName(tableName)} ADD ${c}`}));
-      
+
+    if (Array.isArray(constraints)) {
+      return constraints.map((c) => ({
+        content: c,
+        alterQuery: `ALTER TABLE ${asName(tableName)} ADD ${c}`,
+      }));
     } else {
       const constraintNames = Object.keys(constraints);
-      return constraintNames.map(constraintName => {
+      return constraintNames.map((constraintName) => {
         const _cnstr = constraints[constraintName]!;
-        const constraintDef = typeof _cnstr === "string"? _cnstr : `${_cnstr.type} (${_cnstr.content})`;
-        
+        const constraintDef =
+          typeof _cnstr === "string"
+            ? _cnstr
+            : `${_cnstr.type} (${_cnstr.content})`;
+
         /** Drop constraints with the same name */
         // const existingConstraint = constraints.some(c => c.conname === constraintName);
         // if(existingConstraint){
         //   if(canDrop) queries.push(`ALTER TABLE ${asName(tableName)} DROP CONSTRAINT ${asName(constraintName)};`);
         // }
-        
+
         const alterQuery = `ALTER TABLE ${asName(tableName)} ADD CONSTRAINT ${asName(constraintName)} ${constraintDef};`;
 
         return { name: constraintName, alterQuery, content: constraintDef };
       });
     }
   }
-}
+};
 
 export type ColConstraint = {
   name: string;
@@ -56,14 +63,18 @@ export type ColConstraint = {
   cols: Array<string>;
   definition: string;
   schema: string;
-}
+};
 type ColConstraintsArgs = {
   db: DB | pgPromise.ITask<{}>;
   table?: string;
   column?: string;
   types?: ColConstraint["type"][];
-}
-export const getColConstraintsQuery = ({ column, table, types }: Omit<ColConstraintsArgs, "db">) => {
+};
+export const getColConstraintsQuery = ({
+  column,
+  table,
+  types,
+}: Omit<ColConstraintsArgs, "db">) => {
   let query = `
     SELECT *
     FROM (             
@@ -86,10 +97,15 @@ export const getColConstraintsQuery = ({ column, table, types }: Omit<ColConstra
   `;
   if (table) query += `\nAND "table" = ${asValue(table)}`;
   if (column) query += `\nAND cols @> ARRAY[${asValue(column)}]`;
-  if (types?.length) query += `\nAND type IN (${types.map(v => asValue(v)).join(", ")})`;
+  if (types?.length)
+    query += `\nAND type IN (${types.map((v) => asValue(v)).join(", ")})`;
   return query;
-}
-export const getColConstraints = ({ db, column, table, types }: ColConstraintsArgs ): Promise<ColConstraint[]>  => {
-  
+};
+export const getColConstraints = ({
+  db,
+  column,
+  table,
+  types,
+}: ColConstraintsArgs): Promise<ColConstraint[]> => {
   return db.manyOrNone(getColConstraintsQuery({ column, table, types }));
-}
+};

package/lib/TableConfig/getFutureTableSchema.ts

@@ -2,42 +2,53 @@ import { asName } from "prostgles-types";
 import { pgp } from "../DboBuilder/DboBuilder";
 import { DB } from "../Prostgles";
 import { ColumnMinimalInfo, getTableColumns } from "./getColumnDefinitionQuery";
-import { ColConstraint, ConstraintDef, getColConstraints } from "./getConstraintDefinitionQueries";
+import {
+  ColConstraint,
+  ConstraintDef,
+  getColConstraints,
+} from "./getConstraintDefinitionQueries";
 
 type Args = {
-  db: DB, 
-  columnDefs: string[]; 
+  db: DB;
+  columnDefs: string[];
   tableName: string;
   constraintDefs?: ConstraintDef[];
 };
 
 /**
- * Given a table name, column definitions and constraint definitions, 
+ * Given a table name, column definitions and constraint definitions,
  * returns structured resulting column definitions and constraints of the table
  */
-export const getFutureTableSchema = async ({ columnDefs, tableName, constraintDefs = [], db }: Args): Promise<{
+export const getFutureTableSchema = async ({
+  columnDefs,
+  tableName,
+  constraintDefs = [],
+  db,
+}: Args): Promise<{
   constraints: ColConstraint[];
   cols: ColumnMinimalInfo[];
-}> => { 
+}> => {
   const { TransactionMode, isolationLevel } = pgp.txMode;
-   
+
   let constraints: ColConstraint[] = [];
   let cols: ColumnMinimalInfo[] = [];
   const ROLLBACK = "Rollback";
   try {
     const txMode = new TransactionMode({
-      tiLevel: isolationLevel.serializable
+      tiLevel: isolationLevel.serializable,
     });
-    await db.tx({ mode: txMode }, async t => {
-
+    await db.tx({ mode: txMode }, async (t) => {
       /** To prevent deadlocks we use a random table name -> Not feasible because named constraints cannot be recreated without dropping the existing ones from actual table */
-      // const tableEsc = asName(tableName.slice(0, 12) + (await t.oneOrNone(`SELECT md5(now()::text) as md5`)).md5); 
-      
+      // const tableEsc = asName(tableName.slice(0, 12) + (await t.oneOrNone(`SELECT md5(now()::text) as md5`)).md5);
+
       const tableEsc = asName(tableName);
 
-      const consQueries = constraintDefs.map(c => 
-        `ALTER TABLE ${tableEsc} ADD ${c.name? ` CONSTRAINT ${asName(c.name)}` : ""} ${c.content};`
-      ).join("\n");
+      const consQueries = constraintDefs
+        .map(
+          (c) =>
+            `ALTER TABLE ${tableEsc} ADD ${c.name ? ` CONSTRAINT ${asName(c.name)}` : ""} ${c.content};`,
+        )
+        .join("\n");
 
       const query = `
         DROP TABLE IF EXISTS ${tableEsc} CASCADE;
@@ -51,18 +62,17 @@ export const getFutureTableSchema = async ({ columnDefs, tableName, constraintDe
 
       constraints = await getColConstraints({ db: t, table: tableName });
       cols = await getTableColumns({ db: t, table: tableName });
- 
+
       /** Rollback */
       return Promise.reject(new Error(ROLLBACK));
     });
-
-  } catch(e: any){
-    if(e instanceof Error && e.message === ROLLBACK) {
+  } catch (e: any) {
+    if (e instanceof Error && e.message === ROLLBACK) {
       // Ignore
     } else {
       throw e;
     }
   }
-  
+
   return { cols, constraints };
-}
+};

package/lib/TableConfig/getPGIndexes.ts

@@ -13,8 +13,11 @@ type PGIndex = {
   size: string;
   description: string | null;
 };
-export const getPGIndexes = async (db: DB, tableName: string, schema: string): Promise<PGIndex[]> => {
-
+export const getPGIndexes = async (
+  db: DB,
+  tableName: string,
+  schema: string,
+): Promise<PGIndex[]> => {
   const indexQuery = `
     SELECT n.nspname as schemaname,
       c.relname as indexname,
@@ -48,6 +51,6 @@ export const getPGIndexes = async (db: DB, tableName: string, schema: string): P
     AND c2.relname = \${tableName}
     AND n.nspname = \${schema}
     ORDER BY 1,2;
-    `
+    `;
   return db.any(indexQuery, { tableName, schema });
-};
+};

package/lib/TableConfig/getTableColumnQueries.ts

@@ -1,8 +1,17 @@
-import { getKeys, asName as _asName, isObject, asName, getObjectEntries } from "prostgles-types";
+import {
+  getKeys,
+  asName as _asName,
+  isObject,
+  asName,
+  getObjectEntries,
+} from "prostgles-types";
 import { DB, DBHandlerServer } from "../Prostgles";
 import { validate_jsonb_schema_sql } from "../JSONBValidation/validate_jsonb_schema_sql";
-import { getColumnDefinitionQuery, getTableColumns } from "./getColumnDefinitionQuery";
-import { TableConfig } from "./TableConfig"; 
+import {
+  getColumnDefinitionQuery,
+  getTableColumns,
+} from "./getColumnDefinitionQuery";
+import { TableConfig } from "./TableConfig";
 import { getFutureTableSchema } from "./getFutureTableSchema";
 
 type Args = {
@@ -10,19 +19,26 @@ type Args = {
   tableConf: TableConfig[string];
   tableName: string;
   tableHandler: DBHandlerServer[string] | undefined;
-}
+};
 
 /**
  * Given a tableHandler, table name, column definitions and constraint definitions,
  * returns the queries to align any existing table with the given column definitions
  */
-export const getTableColumnQueries = async ({ db, tableConf, tableName, tableHandler }: Args): Promise<undefined | {
-  columnDefs: string[];
-  newColumnDefs: string[];
-  fullQuery: string;
-  isCreate: boolean;
-}> => {
-
+export const getTableColumnQueries = async ({
+  db,
+  tableConf,
+  tableName,
+  tableHandler,
+}: Args): Promise<
+  | undefined
+  | {
+      columnDefs: string[];
+      newColumnDefs: string[];
+      fullQuery: string;
+      isCreate: boolean;
+    }
+> => {
   let newColumnDefs: string[] = [];
   const droppedColNames: string[] = [];
   const alteredColQueries: string[] = [];
@@ -32,89 +48,121 @@ export const getTableColumnQueries = async ({ db, tableConf, tableName, tableHan
   if (!("columns" in tableConf && tableConf.columns)) {
     return undefined;
   }
-  
-  const hasJSONBValidation = getKeys(tableConf.columns).some(c => {
+
+  const hasJSONBValidation = getKeys(tableConf.columns).some((c) => {
     const cConf = tableConf.columns?.[c];
-    return cConf && isObject(cConf) && (cConf.jsonbSchema || cConf.jsonbSchemaType)
+    return (
+      cConf && isObject(cConf) && (cConf.jsonbSchema || cConf.jsonbSchemaType)
+    );
   });
 
   /** Must install validation function */
-  if(hasJSONBValidation){
+  if (hasJSONBValidation) {
     try {
       await db.any(validate_jsonb_schema_sql);
-    } catch(err: any){
-      console.error("Could not install the jsonb validation function due to error: ", err);
+    } catch (err: any) {
+      console.error(
+        "Could not install the jsonb validation function due to error: ",
+        err,
+      );
       throw err;
     }
   }
 
   const columns = getObjectEntries(tableConf.columns).filter(([_, colDef]) => {
     /** Exclude NamedJoinColumn  */
-    return typeof colDef === "string" || !("joinDef" in colDef)
+    return typeof colDef === "string" || !("joinDef" in colDef);
   });
 
   const colDefs: { name: string; def: string }[] = [];
-  
-  for (const [colName, colConf] of columns) {
 
+  for (const [colName, colConf] of columns) {
     /* Get column definition */
-    const colDef = await getColumnDefinitionQuery({ colConf, column: colName.toString(), db, table: tableName });
-    if(colDef){
-      colDefs.push({ name: colName.toString(), def: colDef});
+    const colDef = await getColumnDefinitionQuery({
+      colConf,
+      column: colName.toString(),
+      db,
+      table: tableName,
+    });
+    if (colDef) {
+      colDefs.push({ name: colName.toString(), def: colDef });
     }
   }
-  const columnDefs = colDefs.map(c => c.def);
+  const columnDefs = colDefs.map((c) => c.def);
 
-  if(!colDefs.length){
+  if (!colDefs.length) {
     return undefined;
   }
 
-
   const ALTERQ = `ALTER TABLE ${asName(tableName)}`;
   if (!tableHandler) {
-    newColumnDefs.push(...colDefs.map(c => c.def));
-
+    newColumnDefs.push(...colDefs.map((c) => c.def));
   } else if (tableHandler) {
     const currCols = await getTableColumns({ db, table: tableName });
 
     /** Add new columns */
-    newColumnDefs = colDefs.filter(nc => !tableHandler.columns?.some(c => nc.name === c.name)).map(c => c.def);
-    
+    newColumnDefs = colDefs
+      .filter((nc) => !tableHandler.columns?.some((c) => nc.name === c.name))
+      .map((c) => c.def);
+
     /** Altered/Dropped columns */
-    const { cols: futureCols } = await getFutureTableSchema({ tableName, columnDefs, constraintDefs: [], db });
-    currCols.forEach(c => {
-      const newCol = futureCols.find(nc => nc.column_name === c.column_name);
-      if(!newCol){
+    const { cols: futureCols } = await getFutureTableSchema({
+      tableName,
+      columnDefs,
+      constraintDefs: [],
+      db,
+    });
+    currCols.forEach((c) => {
+      const newCol = futureCols.find((nc) => nc.column_name === c.column_name);
+      if (!newCol) {
         droppedColNames.push(c.column_name);
-      } else if(newCol.nullable !== c.nullable){
-        alteredColQueries.push(`${ALTERQ} ALTER COLUMN ${asName(c.column_name)} ${newCol.nullable? "DROP" : "SET"} NOT NULL;`)
-      } else if(newCol.udt_name !== c.udt_name){
-        alteredColQueries.push(`${ALTERQ} ALTER COLUMN ${asName(c.column_name)} TYPE ${newCol.udt_name} USING ${asName(c.column_name)}::${newCol.udt_name};`)
-      } else if(newCol.column_default !== c.column_default){
-        const colConfig = colDefs.find(cd => cd.name === c.column_name);
-        if(["serial", "bigserial"].some(t => colConfig?.def.toLowerCase().includes(` ${t}`)) && c.column_default?.toLowerCase().includes("nextval")){
+      } else if (newCol.nullable !== c.nullable) {
+        alteredColQueries.push(
+          `${ALTERQ} ALTER COLUMN ${asName(c.column_name)} ${newCol.nullable ? "DROP" : "SET"} NOT NULL;`,
+        );
+      } else if (newCol.udt_name !== c.udt_name) {
+        alteredColQueries.push(
+          `${ALTERQ} ALTER COLUMN ${asName(c.column_name)} TYPE ${newCol.udt_name} USING ${asName(c.column_name)}::${newCol.udt_name};`,
+        );
+      } else if (newCol.column_default !== c.column_default) {
+        const colConfig = colDefs.find((cd) => cd.name === c.column_name);
+        if (
+          ["serial", "bigserial"].some((t) =>
+            colConfig?.def.toLowerCase().includes(` ${t}`),
+          ) &&
+          c.column_default?.toLowerCase().includes("nextval")
+        ) {
           /** Ignore SERIAL/BIGSERIAL <> nextval mismatch */
         } else {
-          alteredColQueries.push(`${ALTERQ} ALTER COLUMN ${asName(c.column_name)} ${newCol.column_default === null? "DROP DEFAULT" : `SET DEFAULT ${newCol.column_default}`};`)
+          alteredColQueries.push(
+            `${ALTERQ} ALTER COLUMN ${asName(c.column_name)} ${newCol.column_default === null ? "DROP DEFAULT" : `SET DEFAULT ${newCol.column_default}`};`,
+          );
         }
       }
     });
   }
 
-  if (!tableHandler || tableConf.dropIfExists || tableConf.dropIfExistsCascade) {
+  if (
+    !tableHandler ||
+    tableConf.dropIfExists ||
+    tableConf.dropIfExistsCascade
+  ) {
     isCreate = true;
     const DROPQ = `DROP TABLE IF EXISTS ${asName(tableName)}`;
-    fullQuery = ([
-      ...(tableConf.dropIfExists? [`${DROPQ};`] : tableConf.dropIfExistsCascade? [`${DROPQ} CASCADE;`] : []),
+    fullQuery = [
+      ...(tableConf.dropIfExists
+        ? [`${DROPQ};`]
+        : tableConf.dropIfExistsCascade
+          ? [`${DROPQ} CASCADE;`]
+          : []),
       `CREATE TABLE ${asName(tableName)} (`,
-        columnDefs.join(", \n"),
-      `);`
-    ].join("\n"));
-
+      columnDefs.join(", \n"),
+      `);`,
+    ].join("\n");
   } else {
     fullQuery = [
-      ...droppedColNames.map(c => `${ALTERQ} DROP COLUMN ${asName(c)};`),
-      ...newColumnDefs.map(c => `${ALTERQ} ADD COLUMN ${c};`),
+      ...droppedColNames.map((c) => `${ALTERQ} DROP COLUMN ${asName(c)};`),
+      ...newColumnDefs.map((c) => `${ALTERQ} ADD COLUMN ${c};`),
       ...alteredColQueries,
     ].join("\n");
   }
@@ -124,6 +172,5 @@ export const getTableColumnQueries = async ({ db, tableConf, tableName, tableHan
     columnDefs,
     isCreate,
     newColumnDefs,
-  }
-
-}
+  };
+};