prostgles-server 4.2.567 → 4.2.570

package/lib/TableConfig/{TableConfig.ts → TableConfigTypes.ts}

@@ -1,18 +1,16 @@
+import type pgPromise from "pg-promise";
 import type {
   ALLOWED_CONTENT_TYPE,
   ALLOWED_EXTENSION,
   AnyObject,
-  ColumnInfo,
   DBSchema,
   JSONB,
+  MaybePromise,
   StrictUnion,
 } from "prostgles-types";
-import { isObject } from "prostgles-types";
 import type { JoinInfo, LocalParams } from "../DboBuilder/DboBuilder";
-import type { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
-import { uploadFile } from "../DboBuilder/uploadFile";
 import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
-import type { DB, DBHandlerServer, Prostgles } from "../Prostgles";
+import type { DB, DBHandlerServer } from "../Prostgles";
 import type {
   AfterAllTsTrigger,
   AfterEachTsTrigger,
@@ -21,37 +19,14 @@ import type {
   SyncConfig,
   ValidateRowArgsCommon,
 } from "../PublishParser/PublishParser";
-import {
-  DEFAULT_SYNC_BATCH_SIZE,
-  DEFAULT_SYNC_THROTTLE,
-} from "../PubSubManager/PubSubManagerUtils";
-import { initTableConfig } from "./initTableConfig";
 
-type ColExtraInfo = {
+export type ColExtraInfo = {
   min?: string | number;
   max?: string | number;
   hint?: string;
 };
 
-type LangToTranslation = Record<string, string>;
-
-export const parseI18N = <Config extends LangToTranslation>(params: {
-  config?: Config | string;
-  lang?: string;
-  defaultLang: string;
-  defaultValue: string | undefined;
-}): undefined | string => {
-  const { config, lang, defaultLang, defaultValue } = params;
-  if (config) {
-    if (isObject(config)) {
-      return config[lang ?? defaultLang] ?? config[defaultLang];
-    } else if (typeof config === "string") {
-      return config;
-    }
-  }
-
-  return defaultValue;
-};
+export type LangToTranslation = Record<string, string>;
 
 type BaseTableDefinition<R = AnyObject, DBX = DBHandlerServer> = {
   info?: {
@@ -71,6 +46,17 @@ type BaseTableDefinition<R = AnyObject, DBX = DBHandlerServer> = {
     beforeEach?: BeforeEachTsTrigger<R, DBX>[];
     afterEach?: AfterEachTsTrigger<R, DBX>[];
     afterAll?: AfterAllTsTrigger<R, DBX>[];
+    onInsteadOfDelete?: (args: {
+      dbx: DBX;
+      tx: pgPromise.ITask<{}>;
+      returningQuery: string;
+      isOneOrNone: boolean;
+      queryType: "any" | "none";
+      filterOpts: {
+        where: string;
+        filter: AnyObject;
+      };
+    }) => Promise<AnyObject[]>;
   };
   triggers?: {
     [triggerName: string]: {
@@ -254,7 +240,7 @@ export type TableDefinition<
   onMount?: (params: {
     dbo: DBHandlerServer;
     _db: DB;
-  }) => Promise<void | { onUnmount: () => void }>;
+  }) => MaybePromise<void | { onUnmount: () => void }>;
   columns?: {
     [column_name: string]: ColumnConfig<LANG_IDS>;
   };
@@ -268,7 +254,7 @@ export type TableDefinition<
               dropIfExists?: boolean;
               /**
                * E.g.:
-               * colname
+               * columnName
                * col1, col2
                * col1 > col3
                */
@@ -352,188 +338,3 @@ export type TableConfig<LANG_IDS = { en: 1 }, S = void> =
   : {
       [table_name: string]: TableDefinition<LANG_IDS> | LookupTableDefinition<LANG_IDS>;
     };
-
-/**
- * Will be run between initSQL and fileTable
- */
-export default class TableConfigurator {
-  instanceId = Date.now() + Math.random();
-
-  get config() {
-    return this.prostgles.opts.tableConfig ?? {};
-  }
-  get dbo(): DBHandlerServer {
-    if (!this.prostgles.dbo) throw "this.prostgles.dbo missing";
-    return this.prostgles.dbo;
-  }
-  get db(): DB {
-    if (!this.prostgles.db) throw "this.prostgles.db missing";
-    return this.prostgles.db;
-  }
-  prostgles: Prostgles;
-
-  constructor(prostgles: Prostgles) {
-    this.prostgles = prostgles;
-  }
-
-  destroy = async () => {
-    for (const { onUnmount } of Object.values(this.tableOnMounts)) {
-      try {
-        await onUnmount();
-      } catch (error) {
-        console.error(error);
-      }
-    }
-  };
-
-  tableOnMounts: Record<string, { onUnmount: () => void | Promise<void> }> = {};
-  setTableOnMounts = async () => {
-    this.tableOnMounts = {};
-    for (const [tableName, tableConfig] of Object.entries(this.config)) {
-      if ("onMount" in tableConfig && tableConfig.onMount) {
-        const cleanup = await tableConfig.onMount({
-          dbo: this.dbo,
-          _db: this.db,
-        });
-        if (cleanup) {
-          this.tableOnMounts[tableName] = cleanup;
-        }
-      }
-    }
-  };
-
-  getColumnConfig = (tableName: string, colName: string): ColumnConfig | undefined => {
-    const tconf = this.config[tableName];
-    if (tconf && "columns" in tconf) {
-      return tconf.columns?.[colName];
-    }
-    return undefined;
-  };
-
-  getTableSyncConfig = (tableName: string) => {
-    const syncConfig = this.config[tableName]?.syncConfig;
-    return (
-      syncConfig && {
-        ...syncConfig,
-        batch_size: syncConfig.batch_size ?? DEFAULT_SYNC_BATCH_SIZE,
-        throttle: syncConfig.throttle ?? DEFAULT_SYNC_THROTTLE,
-      }
-    );
-  };
-
-  getTableLabel = (params: { tableName: string; lang?: string }) => {
-    const tconf = this.config[params.tableName];
-
-    return parseI18N({
-      config: tconf?.info?.label,
-      lang: params.lang,
-      defaultLang: "en",
-      defaultValue: params.tableName,
-    });
-  };
-
-  getColInfo = (params: {
-    col: string;
-    table: string;
-    lang?: string;
-  }): (ColExtraInfo & { label?: string } & Pick<ColumnInfo, "jsonbSchema">) | undefined => {
-    const colConf = this.getColumnConfig(params.table, params.col);
-    let result: Partial<ReturnType<typeof this.getColInfo>> = undefined;
-    if (colConf) {
-      if (isObject(colConf)) {
-        const { jsonbSchema, jsonbSchemaType, info } = colConf;
-        result = {
-          ...info,
-          ...((jsonbSchema || jsonbSchemaType) && {
-            jsonbSchema: {
-              nullable: colConf.nullable,
-              ...(jsonbSchema || { type: jsonbSchemaType }),
-            },
-          }),
-        };
-
-        /**
-         * Get labels from TableConfig if specified
-         */
-        if (colConf.label) {
-          const { lang } = params;
-          const lbl = colConf.label;
-          if (["string", "object"].includes(typeof lbl)) {
-            if (typeof lbl === "string") {
-              result ??= {};
-              result.label = lbl;
-            } else if (lang && (lbl[lang as "en"] || lbl.en)) {
-              result ??= {};
-              result.label = lbl[lang as "en"] || lbl.en;
-            }
-          }
-        }
-      }
-    }
-
-    return result;
-  };
-
-  checkColVal = (params: { col: string; table: string; value?: number | string }): void => {
-    const conf = this.getColInfo(params);
-    if (conf) {
-      const { value } = params;
-      const { min, max } = conf;
-      if (min !== undefined && value !== undefined && value < min)
-        throw `${params.col} must be greater than ${min}`;
-      if (max !== undefined && value !== undefined && value > max)
-        throw `${params.col} must be less than ${max}`;
-    }
-  };
-
-  getJoinInfo = (sourceTable: string, targetTable: string): JoinInfo | undefined => {
-    if (
-      sourceTable in this.config &&
-      this.config[sourceTable] &&
-      "columns" in this.config[sourceTable]
-    ) {
-      const td = this.config[sourceTable];
-      if ("columns" in td && td.columns?.[targetTable]) {
-        const cd = td.columns[targetTable];
-        if (isObject(cd) && "joinDef" in cd) {
-          if (!cd.joinDef) throw "cd.joinDef missing";
-          const { joinDef } = cd;
-          const res: JoinInfo = {
-            expectOne: false,
-            paths: joinDef.map(({ sourceTable, targetTable: table, on }) => ({
-              source: sourceTable,
-              target: targetTable,
-              table,
-              on,
-            })),
-          };
-
-          return res;
-        }
-      }
-    }
-    return undefined;
-  };
-
-  getPreInsertRow = async (
-    tableHandler: TableHandler,
-    args: Pick<
-      GetPreInsertRowArgs,
-      "localParams" | "row" | "validate" | "dbx" | "tx" | "command" | "data"
-    >,
-  ): Promise<AnyObject> => {
-    const tableHook = this.config[tableHandler.name]?.hooks?.getPreInsertRow;
-    if (tableHandler.is_media) {
-      return uploadFile.bind(tableHandler)(args);
-    }
-    if (tableHook) {
-      return tableHook(args);
-    }
-
-    return args.row;
-  };
-
-  prevInitQueryHistory?: string[];
-  initialising = false;
-  init = initTableConfig.bind(this);
-}

package/lib/TableConfig/TableConfigurator.ts

@@ -0,0 +1,191 @@
+import type { ColumnInfo } from "prostgles-types";
+import { isObject } from "prostgles-types";
+import type { JoinInfo } from "../DboBuilder/DboBuilder";
+import type { DB, DBHandlerServer, Prostgles } from "../Prostgles";
+import {
+  DEFAULT_SYNC_BATCH_SIZE,
+  DEFAULT_SYNC_THROTTLE,
+} from "../PubSubManager/PubSubManagerUtils";
+import { initTableConfig } from "./initTableConfig";
+import type { ColExtraInfo, ColumnConfig, LangToTranslation } from "./TableConfigTypes";
+
+/**
+ * Runs after initSQL  
+ */
+export class TableConfigurator {
+  instanceId = Date.now() + Math.random();
+
+  get config() {
+    return this.prostgles.mergedTableConfig ?? {};
+  }
+  get dbo(): DBHandlerServer {
+    if (!this.prostgles.dbo) throw "this.prostgles.dbo missing";
+    return this.prostgles.dbo;
+  }
+  get db(): DB {
+    if (!this.prostgles.db) throw "this.prostgles.db missing";
+    return this.prostgles.db;
+  }
+  prostgles: Prostgles;
+
+  constructor(prostgles: Prostgles) {
+    this.prostgles = prostgles;
+  }
+
+  destroy = async () => {
+    for (const { onUnmount } of Object.values(this.tableOnMounts)) {
+      try {
+        await onUnmount();
+      } catch (error) {
+        console.error(error);
+      }
+    }
+  };
+
+  tableOnMounts: Record<string, { onUnmount: () => void | Promise<void> }> = {};
+  setTableOnMounts = async () => {
+    this.tableOnMounts = {};
+    for (const [tableName, tableConfig] of Object.entries(this.config)) {
+      if ("onMount" in tableConfig && tableConfig.onMount) {
+        const cleanup = await tableConfig.onMount({
+          dbo: this.dbo,
+          _db: this.db,
+        });
+        if (cleanup) {
+          this.tableOnMounts[tableName] = cleanup;
+        }
+      }
+    }
+  };
+
+  getColumnConfig = (tableName: string, colName: string): ColumnConfig | undefined => {
+    const tableConfig = this.config[tableName];
+    if (tableConfig && "columns" in tableConfig) {
+      return tableConfig.columns?.[colName];
+    }
+    return undefined;
+  };
+
+  getTableSyncConfig = (tableName: string) => {
+    const syncConfig = this.config[tableName]?.syncConfig;
+    return (
+      syncConfig && {
+        ...syncConfig,
+        batch_size: syncConfig.batch_size ?? DEFAULT_SYNC_BATCH_SIZE,
+        throttle: syncConfig.throttle ?? DEFAULT_SYNC_THROTTLE,
+      }
+    );
+  };
+
+  getTableLabel = (params: { tableName: string; lang?: string }) => {
+    const tableConfig = this.config[params.tableName];
+
+    return parseI18N({
+      config: tableConfig?.info?.label,
+      lang: params.lang,
+      defaultLang: "en",
+      defaultValue: params.tableName,
+    });
+  };
+
+  getColInfo = (params: {
+    col: string;
+    table: string;
+    lang?: string;
+  }): (ColExtraInfo & { label?: string } & Pick<ColumnInfo, "jsonbSchema">) | undefined => {
+    const colConf = this.getColumnConfig(params.table, params.col);
+    let result: Partial<ReturnType<typeof this.getColInfo>> = undefined;
+    if (colConf) {
+      if (isObject(colConf)) {
+        const { jsonbSchema, jsonbSchemaType, info } = colConf;
+        result = {
+          ...info,
+          ...((jsonbSchema || jsonbSchemaType) && {
+            jsonbSchema: {
+              nullable: colConf.nullable,
+              ...(jsonbSchema || { type: jsonbSchemaType }),
+            },
+          }),
+        };
+
+        /**
+         * Get labels from TableConfig if specified
+         */
+        if (colConf.label) {
+          const { lang } = params;
+          const lbl = colConf.label;
+          if (["string", "object"].includes(typeof lbl)) {
+            if (typeof lbl === "string") {
+              result ??= {};
+              result.label = lbl;
+            } else if (lang && (lbl[lang as "en"] || lbl.en)) {
+              result ??= {};
+              result.label = lbl[lang as "en"] || lbl.en;
+            }
+          }
+        }
+      }
+    }
+
+    return result;
+  };
+
+  checkColVal = (params: { col: string; table: string; value?: number | string }): void => {
+    const conf = this.getColInfo(params);
+    if (conf) {
+      const { value } = params;
+      const { min, max } = conf;
+      if (min !== undefined && value !== undefined && value < min)
+        throw `${params.col} must be greater than ${min}`;
+      if (max !== undefined && value !== undefined && value > max)
+        throw `${params.col} must be less than ${max}`;
+    }
+  };
+
+  getJoinInfo = (sourceTable: string, targetTable: string): JoinInfo | undefined => {
+    const sourceTableConfig = this.config[sourceTable];
+    if (sourceTableConfig && "columns" in sourceTableConfig) {
+      const targetColConfig = sourceTableConfig.columns?.[targetTable];
+      if (targetColConfig) {
+        if (isObject(targetColConfig) && "joinDef" in targetColConfig) {
+          if (!targetColConfig.joinDef) throw "targetColConfig.joinDef missing";
+          const { joinDef } = targetColConfig;
+          const res: JoinInfo = {
+            expectOne: false,
+            paths: joinDef.map(({ sourceTable, targetTable: table, on }) => ({
+              source: sourceTable,
+              target: targetTable,
+              table,
+              on,
+            })),
+          };
+
+          return res;
+        }
+      }
+    }
+    return undefined;
+  };
+
+  prevInitQueryHistory?: string[];
+  initialising = false;
+  init = initTableConfig.bind(this);
+}
+
+export const parseI18N = <Config extends LangToTranslation>(params: {
+  config?: Config | string;
+  lang?: string;
+  defaultLang: string;
+  defaultValue: string | undefined;
+}): undefined | string => {
+  const { config, lang, defaultLang, defaultValue } = params;
+  if (config) {
+    if (isObject(config)) {
+      return config[lang ?? defaultLang] ?? config[defaultLang];
+    } else if (typeof config === "string") {
+      return config;
+    }
+  }
+
+  return defaultValue;
+};

package/lib/TableConfig/applyTableConfig.ts

@@ -36,7 +36,7 @@ export const applyTableConfig = async (prostgles: Prostgles, commit = false) =>
   const { fileTable, tableConfig, tableConfigMigrations, onLog, sqlFilePath } = prostgles.opts;
   const createSchemaQ = await getTableConfigSchemaQueries(
     { fileTable, tableConfig, tableConfigMigrations, sqlFilePath, onLog },
-    utils
+    utils,
   );
 
   /**
@@ -72,11 +72,10 @@ export const applyTableConfig = async (prostgles: Prostgles, commit = false) =>
         [
           dropTablesQ,
           ...createSchemaQ.tableQueries,
-          ...createSchemaQ.fileTableSchemaQuery,
           ...createSchemaQ.indexQueries,
           ...createSchemaQ.constraintQueries,
           ...createSchemaQ.triggerQueries,
-        ].join("\n")
+        ].join("\n"),
       )
       .catch((err) => {
         console.error(getQueryErrorPositionInfo(err as ProstglesError));

package/lib/TableConfig/getColumnConfig.ts

@@ -1,9 +1,9 @@
-import type { ColumnConfig, TableConfig } from "../TableConfig/TableConfig";
+import type { ColumnConfig, TableConfig } from "./TableConfigTypes";
 
 export const getColumnConfig = (
   config: TableConfig,
   tableName: string,
-  colName: string
+  colName: string,
 ): ColumnConfig | undefined => {
   const tconf = config[tableName];
   if (tconf && "columns" in tconf) {

package/lib/TableConfig/getColumnSQLDefinitionQuery.ts

@@ -4,7 +4,7 @@ import { VALIDATE_SCHEMA_FUNCNAME } from "../JSONBSchemaValidation/validateJSONB
 import type { DB } from "../Prostgles";
 import { fromEntries } from "../PublishParser/applyScopeToTableRules";
 import { asValue } from "../PubSubManager/PubSubManagerUtils";
-import type { BaseColumnTypes, ColumnConfig } from "./TableConfig";
+import type { BaseColumnTypes, ColumnConfig } from "./TableConfigTypes";
 
 type Args = {
   column: string;
@@ -30,7 +30,7 @@ export const getColumnSQLDefinitionQuery = async ({
   const colNameEsc = escapedColumnName ?? asName(column);
   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 getDefinition = async () => {

package/lib/TableConfig/getConstraintDefinitionQueries.ts

@@ -1,5 +1,5 @@
 import { asName } from "prostgles-types";
-import type { TableConfig } from "./TableConfig";
+import type { TableConfig } from "./TableConfigTypes";
 
 type Args = {
   tableName: string;

package/lib/TableConfig/getCreateSchemaQueries.ts

@@ -3,7 +3,7 @@ import { asName } from "prostgles-types";
 import type { DB } from "../initProstgles";
 import type { ProstglesInitOptions, TableConfigMigrations } from "../ProstglesTypes";
 import { fetchTableConstraints } from "./fetchTableConstraints";
-import type { TableConfig } from "./TableConfig";
+import type { TableConfig } from "./TableConfigTypes";
 export type RequiredUndefined<T> = {
   [K in keyof Required<T>]: T[K];
 };

package/lib/TableConfig/getSchemaDiffQueries.ts

@@ -29,7 +29,7 @@ export const getSchemaDiffQueries = ({
   const droppedTableQueries =
     droppedTableIdents.length ? [`DROP TABLE ${droppedTableIdents.join(", ")} CASCADE;`] : [];
 
-  const droppedColumns: { table_ident: string; column_name: string }[] = [];
+  // const droppedColumns: { table_ident: string; column_name: string }[] = [];
 
   const tableAndColQueries = newSchema
     .flatMap(({ table_ident, table_name, columns }) => {
@@ -42,7 +42,7 @@ export const getSchemaDiffQueries = ({
               (c) =>
                 c.column_name_escaped +
                 " " +
-                newSchemaTableDefinitions[table_name]![c.column_name_escaped]
+                newSchemaTableDefinitions[table_name]![c.column_name_escaped],
             )
             .join(",\n"),
           `);`,
@@ -52,13 +52,13 @@ export const getSchemaDiffQueries = ({
 
       if (!isEqual(columns, oldTable.columns)) return;
 
-      const droppedColumnQueries =
-        oldTable.columns
-          ?.filter((oc) => !columns?.some((c) => c.column_name === oc.column_name))
-          .map((dc) => {
-            droppedColumns.push({ table_ident, column_name: dc.column_name });
-            return `ALTER TABLE ${table_ident} DROP COLUMN ${dc.column_name};`;
-          }) ?? [];
+      // const droppedColumnQueries =
+      //   oldTable.columns
+      //     ?.filter((oc) => !columns?.some((c) => c.column_name === oc.column_name))
+      //     .map((dc) => {
+      //       droppedColumns.push({ table_ident, column_name: dc.column_name });
+      //       return `ALTER TABLE ${table_ident} DROP COLUMN ${dc.column_name};`;
+      //     }) ?? [];
 
       const alteredAndNewColumns =
         columns?.flatMap((c) => {
@@ -76,7 +76,7 @@ export const getSchemaDiffQueries = ({
               `${alterTableQuery} ` +
                 (c.column_default !== null ?
                   `SET DEFAULT ${asValue(c.column_default)};`
-                : `DROP DEFAULT;`)
+                : `DROP DEFAULT;`),
             );
           }
           if (c.udt_name !== oldCol.udt_name) {
@@ -89,7 +89,10 @@ export const getSchemaDiffQueries = ({
           return queries;
         }) ?? [];
 
-      return [...droppedColumnQueries, ...alteredAndNewColumns];
+      return [
+        // ...droppedColumnQueries,
+        ...alteredAndNewColumns,
+      ];
     })
     .filter(isDefined);