prostgles-server 3.0.131 → 3.0.133

package/lib/TableConfig/getColumnDefinitionQuery.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getTableColumns = exports.getColConstraints = exports.getColConstraintsQuery = exports.getColumnDefinitionQuery = void 0;
+exports.getTableColumns = exports.getColumnDefinitionQuery = void 0;
 const prostgles_types_1 = require("prostgles-types");
 const PubSubManager_1 = require("../PubSubManager/PubSubManager");
 const validate_jsonb_schema_sql_1 = require("../JSONBValidation/validate_jsonb_schema_sql");
+const getConstraintDefinitionQueries_1 = require("./getConstraintDefinitionQueries");
 /**
  * Column create statement for a given config
  */
@@ -62,7 +63,7 @@ const getColumnDefinitionQuery = async ({ colConf: colConfRaw, column, db, table
         const namePreffix = 'prostgles_jsonb_';
         const { val: nameEnding } = await db.one("SELECT MD5( ${table} || ${column}  || ${schema}) as val", { table: table, column, schema: jsonbSchemaStr });
         const constraintName = namePreffix + nameEnding;
-        const colConstraints = await (0, exports.getColConstraints)({ db, table, column });
+        const colConstraints = await (0, getConstraintDefinitionQueries_1.getColConstraints)({ db, table, column });
         const existingNonMatchingConstraints = colConstraints.filter(c => c.name.startsWith(namePreffix) && c.name !== constraintName);
         for await (const oldCons of existingNonMatchingConstraints) {
             await db.any(`ALTER TABLE ${(0, prostgles_types_1.asName)(table)} DROP CONSTRAINT ${(0, prostgles_types_1.asName)(oldCons.name)};`);
@@ -82,41 +83,7 @@ const getColumnDefinitionQuery = async ({ colConf: colConfRaw, column, db, table
     }
 };
 exports.getColumnDefinitionQuery = getColumnDefinitionQuery;
-const getColConstraintsQuery = ({ column, table, types }) => {
-    let query = `
-    SELECT *
-    FROM (             
-      SELECT distinct c.conname as name, c.contype as type,
-        pg_get_constraintdef(c.oid) as definition, 
-        nsp.nspname as schema,
-      (SELECT r.relname from pg_class r where r.oid = c.conrelid) as "table", 
-      (SELECT array_agg(attname::text) from pg_attribute 
-      where attrelid = c.conrelid and ARRAY[attnum] <@ c.conkey) as cols
-      -- (SELECT array_agg(attname::text) from pg_attribute 
-      -- where attrelid = c.confrelid and ARRAY[attnum] <@ c.confkey) as fcols, 
-      -- (SELECT r.relname from pg_class r where r.oid = c.confrelid) as ftable
-      FROM pg_catalog.pg_constraint c
-      INNER JOIN pg_catalog.pg_class rel
-      ON rel.oid = c.conrelid
-      INNER JOIN pg_catalog.pg_namespace nsp
-      ON nsp.oid = connamespace
-    ) t   
-    WHERE TRUE 
-  `;
-    if (table)
-        query += `\nAND "table" = ${(0, PubSubManager_1.asValue)(table)}`;
-    if (column)
-        query += `\nAND cols @> ARRAY[${(0, PubSubManager_1.asValue)(column)}]`;
-    if (types?.length)
-        query += `\nAND type IN (${types.map(v => (0, PubSubManager_1.asValue)(v)).join(", ")})`;
-    return query;
-};
-exports.getColConstraintsQuery = getColConstraintsQuery;
-const getColConstraints = ({ db, column, table, types }) => {
-    return db.manyOrNone((0, exports.getColConstraintsQuery)({ column, table, types }));
-};
-exports.getColConstraints = getColConstraints;
-const getTableColumns = ({ db, tableName }) => {
+const getTableColumns = ({ db, table }) => {
     return db.manyOrNone(`
     SELECT table_name, 
       table_schema, column_name, 
@@ -124,6 +91,6 @@ const getTableColumns = ({ db, tableName }) => {
       is_nullable = 'YES' as nullable
     FROM information_schema.columns
     WHERE table_name = $1
-  `, [tableName]);
+  `, [table]);
 };
 exports.getTableColumns = getTableColumns;

package/lib/TableConfig/getColumnDefinitionQuery.ts

@@ -4,6 +4,7 @@ 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 { getColConstraints } from "./getConstraintDefinitionQueries";
 
 type Args = {
   column: string; 
@@ -98,50 +99,7 @@ export const getColumnDefinitionQuery = async ({ colConf: colConfRaw, column, db
   }
 }
 
-export type ColConstraint = {
-  name: string;
-  table: string;
-  type: "c" | "p" | "u" | "f";
-  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">) => {
-  let query = `
-    SELECT *
-    FROM (             
-      SELECT distinct c.conname as name, c.contype as type,
-        pg_get_constraintdef(c.oid) as definition, 
-        nsp.nspname as schema,
-      (SELECT r.relname from pg_class r where r.oid = c.conrelid) as "table", 
-      (SELECT array_agg(attname::text) from pg_attribute 
-      where attrelid = c.conrelid and ARRAY[attnum] <@ c.conkey) as cols
-      -- (SELECT array_agg(attname::text) from pg_attribute 
-      -- where attrelid = c.confrelid and ARRAY[attnum] <@ c.confkey) as fcols, 
-      -- (SELECT r.relname from pg_class r where r.oid = c.confrelid) as ftable
-      FROM pg_catalog.pg_constraint c
-      INNER JOIN pg_catalog.pg_class rel
-      ON rel.oid = c.conrelid
-      INNER JOIN pg_catalog.pg_namespace nsp
-      ON nsp.oid = connamespace
-    ) t   
-    WHERE TRUE 
-  `;
-  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(", ")})`;
-  return query;
-}
-export const getColConstraints = ({ db, column, table, types }: ColConstraintsArgs ): Promise<ColConstraint[]>  => {
-  
-  return db.manyOrNone(getColConstraintsQuery({ column, table, types }));
-}
+
 export type ColumnMinimalInfo = { 
   table_name: string;
   table_schema: string;
@@ -150,7 +108,7 @@ export type ColumnMinimalInfo = {
   udt_name: string;
   nullable: boolean; 
 };
-export const getTableColumns = ({ db, tableName }: { db: DB; tableName: string;}): Promise<ColumnMinimalInfo[]> => {
+export const getTableColumns = ({ db, table }: { db: DB | pgPromise.ITask<{}>; table: string;}): Promise<ColumnMinimalInfo[]> => {
   return db.manyOrNone(`
     SELECT table_name, 
       table_schema, column_name, 
@@ -158,5 +116,5 @@ export const getTableColumns = ({ db, tableName }: { db: DB; tableName: string;}
       is_nullable = 'YES' as nullable
     FROM information_schema.columns
     WHERE table_name = $1
-  `, [tableName]);
+  `, [table]);
 }

package/lib/TableConfig/getConstraintDefinitionQueries.d.ts

@@ -1,8 +1,34 @@
+import pgPromise from "pg-promise";
+import { DB } from "../Prostgles";
 import { TableConfig } from "./TableConfig";
 type Args = {
     tableName: string;
     tableConf: TableConfig[string];
 };
-export declare const getConstraintDefinitionQueries: ({ tableConf, tableName }: Args) => string[] | undefined;
+export type ConstraintDef = {
+    /**
+     * Named constraints are used to show a relevant error message
+     */
+    name?: string;
+    content: string;
+    alterQuery: string;
+};
+export declare const getConstraintDefinitionQueries: ({ tableConf, tableName }: Args) => ConstraintDef[] | undefined;
+export type ColConstraint = {
+    name: string;
+    table: string;
+    type: "c" | "p" | "u" | "f";
+    cols: Array<string>;
+    definition: string;
+    schema: string;
+};
+type ColConstraintsArgs = {
+    db: DB | pgPromise.ITask<{}>;
+    table?: string;
+    column?: string;
+    types?: ColConstraint["type"][];
+};
+export declare const getColConstraintsQuery: ({ column, table, types }: Omit<ColConstraintsArgs, "db">) => string;
+export declare const getColConstraints: ({ db, column, table, types }: ColConstraintsArgs) => Promise<ColConstraint[]>;
 export {};
 //# sourceMappingURL=getConstraintDefinitionQueries.d.ts.map

package/lib/TableConfig/getConstraintDefinitionQueries.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getConstraintDefinitionQueries.d.ts","sourceRoot":"","sources":["getConstraintDefinitionQueries.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,KAAK,IAAI,GAAG;IACV,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAE/B,CAAC;AAEF,eAAO,MAAM,8BAA8B,6BAA8B,IAAI,KAAG,MAAM,EAAE,GAAG,SA2B1F,CAAA"}
+{"version":3,"file":"getConstraintDefinitionQueries.d.ts","sourceRoot":"","sources":["getConstraintDefinitionQueries.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,YAAY,CAAC;AAEnC,OAAO,EAAE,EAAE,EAAE,MAAM,cAAc,CAAC;AAElC,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C,KAAK,IAAI,GAAG;IACV,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAA;CAE/B,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG;IAC1B;;OAEG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AACF,eAAO,MAAM,8BAA8B,6BAA8B,IAAI,KAAG,aAAa,EAAE,GAAG,SA6BjG,CAAA;AAED,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;IAC5B,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAA;AACD,KAAK,kBAAkB,GAAG;IACxB,EAAE,EAAE,EAAE,GAAG,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAC7B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,EAAE,CAAC;CACjC,CAAA;AACD,eAAO,MAAM,sBAAsB,6BAA8B,KAAK,kBAAkB,EAAE,IAAI,CAAC,WAyB9F,CAAA;AACD,eAAO,MAAM,iBAAiB,iCAAkC,kBAAkB,KAAI,QAAQ,aAAa,EAAE,CAG5G,CAAA"}

package/lib/TableConfig/getConstraintDefinitionQueries.js

@@ -1,20 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConstraintDefinitionQueries = void 0;
+exports.getColConstraints = exports.getColConstraintsQuery = exports.getConstraintDefinitionQueries = void 0;
 const prostgles_types_1 = require("prostgles-types");
+const PubSubManager_1 = require("../PubSubManager/PubSubManager");
 const getConstraintDefinitionQueries = ({ tableConf, tableName }) => {
     if ("constraints" in tableConf && tableConf.constraints) {
         const { constraints } = tableConf;
         if (!constraints) {
             return undefined;
         }
-        const queries = [];
         if (Array.isArray(constraints)) {
-            return constraints.map(c => `ALTER TABLE ${(0, prostgles_types_1.asName)(tableName)} ADD ${c}`);
+            return constraints.map(c => ({ content: c, alterQuery: `ALTER TABLE ${(0, prostgles_types_1.asName)(tableName)} ADD ${c}` }));
         }
         else {
             const constraintNames = (0, prostgles_types_1.getKeys)(tableConf.constraints);
-            constraintNames.map(constraintName => {
+            return constraintNames.map(constraintName => {
                 const _cnstr = constraints[constraintName];
                 const constraintDef = typeof _cnstr === "string" ? _cnstr : `${_cnstr.type} (${_cnstr.content})`;
                 /** Drop constraints with the same name */
@@ -22,10 +22,44 @@ const getConstraintDefinitionQueries = ({ tableConf, tableName }) => {
                 // if(existingConstraint){
                 //   if(canDrop) queries.push(`ALTER TABLE ${asName(tableName)} DROP CONSTRAINT ${asName(constraintName)};`);
                 // }
-                queries.push(`ALTER TABLE ${(0, prostgles_types_1.asName)(tableName)} ADD CONSTRAINT ${(0, prostgles_types_1.asName)(constraintName)} ${constraintDef} ;`);
+                const alterQuery = `ALTER TABLE ${(0, prostgles_types_1.asName)(tableName)} ADD CONSTRAINT ${(0, prostgles_types_1.asName)(constraintName)} ${constraintDef};`;
+                return { name: constraintName, alterQuery, content: constraintDef };
             });
-            return queries;
         }
     }
 };
 exports.getConstraintDefinitionQueries = getConstraintDefinitionQueries;
+const getColConstraintsQuery = ({ column, table, types }) => {
+    let query = `
+    SELECT *
+    FROM (             
+      SELECT distinct c.conname as name, c.contype as type,
+        pg_get_constraintdef(c.oid) as definition, 
+        nsp.nspname as schema,
+      (SELECT r.relname from pg_class r where r.oid = c.conrelid) as "table", 
+      (SELECT array_agg(attname::text) from pg_attribute 
+      where attrelid = c.conrelid and ARRAY[attnum] <@ c.conkey) as cols
+      -- (SELECT array_agg(attname::text) from pg_attribute 
+      -- where attrelid = c.confrelid and ARRAY[attnum] <@ c.confkey) as fcols, 
+      -- (SELECT r.relname from pg_class r where r.oid = c.confrelid) as ftable
+      FROM pg_catalog.pg_constraint c
+      INNER JOIN pg_catalog.pg_class rel
+      ON rel.oid = c.conrelid
+      INNER JOIN pg_catalog.pg_namespace nsp
+      ON nsp.oid = connamespace
+    ) t   
+    WHERE TRUE 
+  `;
+    if (table)
+        query += `\nAND "table" = ${(0, PubSubManager_1.asValue)(table)}`;
+    if (column)
+        query += `\nAND cols @> ARRAY[${(0, PubSubManager_1.asValue)(column)}]`;
+    if (types?.length)
+        query += `\nAND type IN (${types.map(v => (0, PubSubManager_1.asValue)(v)).join(", ")})`;
+    return query;
+};
+exports.getColConstraintsQuery = getColConstraintsQuery;
+const getColConstraints = ({ db, column, table, types }) => {
+    return db.manyOrNone((0, exports.getColConstraintsQuery)({ column, table, types }));
+};
+exports.getColConstraints = getColConstraints;

package/lib/TableConfig/getConstraintDefinitionQueries.ts

@@ -1,4 +1,7 @@
+import pgPromise from "pg-promise";
 import { asName, getKeys } from "prostgles-types";
+import { DB } from "../Prostgles";
+import { asValue } from "../PubSubManager/PubSubManager";
 import { TableConfig } from "./TableConfig";
 
 type Args = {
@@ -7,19 +10,28 @@ type Args = {
   // tableConf: BaseTableDefinition<LANG_IDS> & (TableDefinition<LANG_IDS> | LookupTableDefinition<LANG_IDS>)
 };
 
-export const getConstraintDefinitionQueries = ({ tableConf, tableName }: Args): string[] | undefined => {
+export type ConstraintDef = {  
+  /**
+   * Named constraints are used to show a relevant error message
+   */
+  name?: string; 
+  content: string; 
+  alterQuery: string; 
+};
+export const getConstraintDefinitionQueries = ({ tableConf, tableName }: Args): ConstraintDef[] | undefined => {
 
   if ("constraints" in tableConf && tableConf.constraints) {
     const { constraints } = tableConf;
     if(!constraints){
       return undefined;
     }
-    const queries: string[] = [];
+    
     if(Array.isArray(constraints)){
-      return constraints.map(c => `ALTER TABLE ${asName(tableName)} ADD ${c}`);
+      return constraints.map(c => ({ content: c, alterQuery: `ALTER TABLE ${asName(tableName)} ADD ${c}`}));
+      
     } else {
       const constraintNames = getKeys(tableConf.constraints);
-      constraintNames.map(constraintName => {
+      return constraintNames.map(constraintName => {
         const _cnstr = constraints[constraintName];
         const constraintDef = typeof _cnstr === "string"? _cnstr : `${_cnstr.type} (${_cnstr.content})`;
         
@@ -29,9 +41,55 @@ export const getConstraintDefinitionQueries = ({ tableConf, tableName }: Args):
         //   if(canDrop) queries.push(`ALTER TABLE ${asName(tableName)} DROP CONSTRAINT ${asName(constraintName)};`);
         // }
         
-        queries.push(`ALTER TABLE ${asName(tableName)} ADD CONSTRAINT ${asName(constraintName)} ${constraintDef} ;`);
+        const alterQuery = `ALTER TABLE ${asName(tableName)} ADD CONSTRAINT ${asName(constraintName)} ${constraintDef};`;
+
+        return { name: constraintName, alterQuery, content: constraintDef };
       });
-      return queries;
     }
   }
+}
+
+export type ColConstraint = {
+  name: string;
+  table: string;
+  type: "c" | "p" | "u" | "f";
+  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">) => {
+  let query = `
+    SELECT *
+    FROM (             
+      SELECT distinct c.conname as name, c.contype as type,
+        pg_get_constraintdef(c.oid) as definition, 
+        nsp.nspname as schema,
+      (SELECT r.relname from pg_class r where r.oid = c.conrelid) as "table", 
+      (SELECT array_agg(attname::text) from pg_attribute 
+      where attrelid = c.conrelid and ARRAY[attnum] <@ c.conkey) as cols
+      -- (SELECT array_agg(attname::text) from pg_attribute 
+      -- where attrelid = c.confrelid and ARRAY[attnum] <@ c.confkey) as fcols, 
+      -- (SELECT r.relname from pg_class r where r.oid = c.confrelid) as ftable
+      FROM pg_catalog.pg_constraint c
+      INNER JOIN pg_catalog.pg_class rel
+      ON rel.oid = c.conrelid
+      INNER JOIN pg_catalog.pg_namespace nsp
+      ON nsp.oid = connamespace
+    ) t   
+    WHERE TRUE 
+  `;
+  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(", ")})`;
+  return query;
+}
+export const getColConstraints = ({ db, column, table, types }: ColConstraintsArgs ): Promise<ColConstraint[]>  => {
+  
+  return db.manyOrNone(getColConstraintsQuery({ column, table, types }));
 }

package/lib/TableConfig/getFutureTableSchema.d.ts

@@ -0,0 +1,15 @@
+import { DB } from "../Prostgles";
+import { ColumnMinimalInfo } from "./getColumnDefinitionQuery";
+import { ColConstraint, ConstraintDef } from "./getConstraintDefinitionQueries";
+type Args = {
+    db: DB;
+    columnDefs: string[];
+    tableName: string;
+    constraintDefs?: ConstraintDef[];
+};
+export declare const getFutureTableSchema: ({ columnDefs, tableName, constraintDefs, db }: Args) => Promise<{
+    constraints: ColConstraint[];
+    cols: ColumnMinimalInfo[];
+}>;
+export {};
+//# sourceMappingURL=getFutureTableSchema.d.ts.map

package/lib/TableConfig/getFutureTableSchema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getFutureTableSchema.d.ts","sourceRoot":"","sources":["getFutureTableSchema.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,MAAM,cAAc,CAAC;AAElC,OAAO,EAAE,iBAAiB,EAAmB,MAAM,4BAA4B,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,aAAa,EAAqB,MAAM,kCAAkC,CAAC;AAEnG,KAAK,IAAI,GAAG;IACV,EAAE,EAAE,EAAE,CAAC;IACP,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,cAAc,CAAC,EAAE,aAAa,EAAE,CAAC;CAClC,CAAC;AAEF,eAAO,MAAM,oBAAoB,kDAA8D,IAAI;iBACpF,aAAa,EAAE;UACtB,iBAAiB,EAAE;EAyD1B,CAAA"}

package/lib/TableConfig/getFutureTableSchema.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFutureTableSchema = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const getColumnDefinitionQuery_1 = require("./getColumnDefinitionQuery");
+const getConstraintDefinitionQueries_1 = require("./getConstraintDefinitionQueries");
+const getFutureTableSchema = async ({ columnDefs, tableName, constraintDefs = [], db }) => {
+    let constraints = [];
+    let cols = [];
+    const ROLLBACK = "Rollback";
+    try {
+        await db.tx(async (t) => {
+            // const { v } = await t.one("SELECT md5(random()::text) as v");
+            // /** TODO: create all tables in a random new schema */
+            // const randomTableName = `prostgles_constr_${v}`;
+            // /* References are removed to avoid potential issues with ftables missing */
+            // const columnDefsWithoutReferences = columnDefs.map(cdef => {
+            //   const refIdx = cdef.toLowerCase().indexOf(" references ");
+            //   if(refIdx < 0) return cdef;
+            //   return cdef.slice(0, refIdx);
+            // });
+            // const query = `CREATE TABLE ${randomTableName} ( 
+            //     ${columnDefsWithoutReferences.join(",\n")}
+            //   );
+            //   ${alterQueries}
+            // `;
+            const tableEsc = (0, prostgles_types_1.asName)(tableName);
+            const consQueries = constraintDefs.map(c => `ALTER TABLE ${tableEsc} ADD ${c.name ? ` CONSTRAINT ${(0, prostgles_types_1.asName)(c.name)}` : ""} ${c.content};`).join("\n");
+            const query = `
+        DROP TABLE IF EXISTS ${tableEsc} CASCADE;
+        CREATE TABLE ${tableEsc} (
+          ${columnDefs.join(",\n")}
+        );
+        ${consQueries}
+      `;
+            await t.any(query);
+            constraints = await (0, getConstraintDefinitionQueries_1.getColConstraints)({ db: t, table: tableName });
+            cols = await (0, getColumnDefinitionQuery_1.getTableColumns)({ db: t, table: tableName });
+            /** Rollback */
+            return Promise.reject(ROLLBACK);
+        });
+    }
+    catch (e) {
+        if (e !== ROLLBACK) {
+            throw e;
+        }
+    }
+    return { cols, constraints };
+};
+exports.getFutureTableSchema = getFutureTableSchema;

package/lib/TableConfig/getFutureTableSchema.ts

@@ -0,0 +1,73 @@
+import { asName } from "prostgles-types";
+import { DB } from "../Prostgles";
+import { log } from "../PubSubManager/PubSubManager";
+import { ColumnMinimalInfo, getTableColumns } from "./getColumnDefinitionQuery";
+import { ColConstraint, ConstraintDef, getColConstraints } from "./getConstraintDefinitionQueries";
+
+type Args = {
+  db: DB, 
+  columnDefs: string[]; 
+  tableName: string;
+  constraintDefs?: ConstraintDef[];
+};
+
+export const getFutureTableSchema = async ({ columnDefs, tableName, constraintDefs = [], db }: Args): Promise<{
+  constraints: ColConstraint[];
+  cols: ColumnMinimalInfo[];
+}> => {
+
+  let constraints: ColConstraint[] = [];
+  let cols: ColumnMinimalInfo[] = [];
+  const ROLLBACK = "Rollback";
+  try {
+    await db.tx(async t => {
+      // const { v } = await t.one("SELECT md5(random()::text) as v");
+
+      // /** TODO: create all tables in a random new schema */
+      // const randomTableName = `prostgles_constr_${v}`;
+
+      // /* References are removed to avoid potential issues with ftables missing */
+      // const columnDefsWithoutReferences = columnDefs.map(cdef => {
+      //   const refIdx = cdef.toLowerCase().indexOf(" references ");
+      //   if(refIdx < 0) return cdef;
+      //   return cdef.slice(0, refIdx);
+      // });
+
+      
+
+      // const query = `CREATE TABLE ${randomTableName} ( 
+      //     ${columnDefsWithoutReferences.join(",\n")}
+      //   );
+      //   ${alterQueries}
+      // `;
+
+      const tableEsc = asName(tableName); 
+
+      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;
+        CREATE TABLE ${tableEsc} (
+          ${columnDefs.join(",\n")}
+        );
+        ${consQueries}
+      `
+
+      await t.any(query);
+      constraints = await getColConstraints({ db: t, table: tableName });
+      cols = await getTableColumns({ db: t, table: tableName });
+ 
+      /** Rollback */
+      return Promise.reject(ROLLBACK);
+    });
+
+  } catch(e){
+    if(e !== ROLLBACK) {
+      throw e;
+    }
+  }
+
+  return { cols, constraints };
+}

package/lib/TableConfig/getTableColumnQueries.d.ts

@@ -0,0 +1,16 @@
+import { DB, DBHandlerServer } from "../Prostgles";
+import { TableConfig } from "./TableConfig";
+type Args = {
+    db: DB;
+    tableConf: TableConfig[string];
+    tableName: string;
+    tableHandler: DBHandlerServer[string];
+};
+export declare const getTableColumnQueries: ({ db, tableConf, tableName, tableHandler }: Args) => Promise<{
+    columnDefs: string[];
+    newColumnDefs: string[];
+    fullQuery: string;
+    isCreate: boolean;
+}>;
+export {};
+//# sourceMappingURL=getTableColumnQueries.d.ts.map

package/lib/TableConfig/getTableColumnQueries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getTableColumnQueries.d.ts","sourceRoot":"","sources":["getTableColumnQueries.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,EAAE,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAGnD,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAI5C,KAAK,IAAI,GAAG;IACV,EAAE,EAAE,EAAE,CAAC;IACP,SAAS,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,eAAe,CAAC,MAAM,CAAC,CAAC;CACvC,CAAA;AAED,eAAO,MAAM,qBAAqB,+CAAsD,IAAI;gBAC9E,MAAM,EAAE;mBACL,MAAM,EAAE;eACZ,MAAM;cACP,OAAO;EA8GlB,CAAA"}

package/lib/TableConfig/getTableColumnQueries.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTableColumnQueries = void 0;
+const prostgles_types_1 = require("prostgles-types");
+const validate_jsonb_schema_sql_1 = require("../JSONBValidation/validate_jsonb_schema_sql");
+const getColumnDefinitionQuery_1 = require("./getColumnDefinitionQuery");
+const getFutureTableSchema_1 = require("./getFutureTableSchema");
+const getTableColumnQueries = async ({ db, tableConf, tableName, tableHandler }) => {
+    let newColumnDefs = [];
+    const droppedColNames = [];
+    const alteredColQueries = [];
+    let fullQuery = "";
+    let isCreate = false;
+    if ("columns" in tableConf && tableConf.columns) {
+        const hasJSONBValidation = (0, prostgles_types_1.getKeys)(tableConf.columns).some(c => {
+            const cConf = tableConf.columns?.[c];
+            return cConf && (0, prostgles_types_1.isObject)(cConf) && (cConf.jsonbSchema || cConf.jsonbSchemaType);
+        });
+        /** Must install validation function */
+        if (hasJSONBValidation) {
+            try {
+                await db.any(validate_jsonb_schema_sql_1.validate_jsonb_schema_sql);
+            }
+            catch (err) {
+                console.error("Could not install the jsonb validation function due to error: ", err);
+                throw err;
+            }
+        }
+        const columns = (0, prostgles_types_1.getKeys)(tableConf.columns).filter(c => {
+            const colDef = tableConf.columns[c];
+            /** Exclude NamedJoinColumn  */
+            return typeof colDef === "string" || !("joinDef" in colDef);
+        });
+        const colDefs = [];
+        for await (const colName of columns) {
+            const colConf = tableConf.columns[colName];
+            /* Get column definition */
+            const colDef = await (0, getColumnDefinitionQuery_1.getColumnDefinitionQuery)({ colConf, column: colName, db, table: tableName });
+            if (colDef) {
+                colDefs.push({ name: colName, def: colDef });
+            }
+        }
+        const columnDefs = colDefs.map(c => c.def);
+        if (!colDefs.length) {
+            return undefined;
+        }
+        const ALTERQ = `ALTER TABLE ${(0, prostgles_types_1.asName)(tableName)}`;
+        if (!tableHandler) {
+            newColumnDefs.push(...colDefs.map(c => c.def));
+        }
+        else if (tableHandler) {
+            const currCols = await (0, getColumnDefinitionQuery_1.getTableColumns)({ db, table: tableName });
+            /** Add new columns */
+            newColumnDefs = colDefs.filter(nc => !tableHandler.columns?.some(c => nc.name === c.name)).map(c => c.def);
+            /** Altered/Dropped columns */
+            const { cols: futureCols } = await (0, getFutureTableSchema_1.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 ${(0, prostgles_types_1.asName)(c.column_name)} ${newCol.nullable ? "SET" : "DROP"} NOT NULL;`);
+                }
+                else if (newCol.udt_name !== c.udt_name) {
+                    alteredColQueries.push(`${ALTERQ} ALTER COLUMN ${(0, prostgles_types_1.asName)(c.column_name)} TYPE ${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 ${(0, prostgles_types_1.asName)(c.column_name)} ${newCol.column_default === null ? "DROP DEFAULT" : `SET DEFAULT ${newCol.column_default}`};`);
+                    }
+                }
+            });
+        }
+        if (!tableHandler || tableConf.dropIfExists || tableConf.dropIfExistsCascade) {
+            isCreate = true;
+            const DROPQ = `DROP TABLE IF EXISTS ${(0, prostgles_types_1.asName)(tableName)}`;
+            fullQuery = ([
+                ...(tableConf.dropIfExists ? [`${DROPQ};`] : tableConf.dropIfExistsCascade ? [`${DROPQ} CASCADE;`] : []),
+                `CREATE TABLE ${(0, prostgles_types_1.asName)(tableName)} (`,
+                columnDefs.join(", \n"),
+                `);`
+            ].join("\n"));
+        }
+        else {
+            fullQuery = [
+                ...droppedColNames.map(c => `${ALTERQ} DROP COLUMN ${(0, prostgles_types_1.asName)(c)};`),
+                ...newColumnDefs.map(c => `${ALTERQ} ADD COLUMN ${c};`),
+                ...alteredColQueries,
+            ].join("\n");
+        }
+        return {
+            fullQuery,
+            columnDefs,
+            isCreate,
+            newColumnDefs,
+        };
+    }
+    else {
+        return undefined;
+    }
+};
+exports.getTableColumnQueries = getTableColumnQueries;