prostgles-server 4.2.344 → 4.2.345

package/lib/Auth/utils/setCookieAndGoToReturnURLIFSet.ts

@@ -1,15 +1,10 @@
-import { includes } from "prostgles-types";
-import {
-  AUTH_ROUTES_AND_PARAMS,
-  HTTP_FAIL_CODES,
-  matchesRoute,
-  type AuthHandler,
-} from "../AuthHandler";
+import { AUTH_ROUTES_AND_PARAMS, HTTP_FAIL_CODES, type AuthHandler } from "../AuthHandler";
 import type { ExpressReq } from "../AuthTypes";
 import type { LoginResponseHandler } from "../endpoints/setLoginRequestHandler";
 import { getBasicSessionErrorCode } from "../login";
 import { getReturnUrl } from "./getReturnUrl";
 import { getSafeReturnURL } from "./getSafeReturnURL";
+import { matchesRoute } from "./matchesRoute";
 
 export function validateSessionAndSetCookie(
   this: AuthHandler,

package/lib/Auth/utils/upsertNamedExpressMiddleware.ts

@@ -1,6 +1,5 @@
 import type e from "express";
-import { RequestHandler } from "express";
-import { removeExpressRouteByName } from "../../FileManager/FileManager";
+import type { RequestHandler } from "express";
 import type { ExpressApp } from "../../RestApi";
 
 export const upsertNamedExpressMiddleware = (
@@ -13,3 +12,15 @@ export const upsertNamedExpressMiddleware = (
   removeExpressRouteByName(app as ExpressApp, name);
   app.use(handler);
 };
+
+export const removeExpressRouteByName = (app: ExpressApp | undefined, name: string) => {
+  const routes = app?._router?.stack;
+  if (routes) {
+    app._router!.stack = routes.filter((route) => {
+      if (route.name === name) {
+        return false;
+      }
+      return true;
+    });
+  }
+};

package/lib/DBEventsManager.ts

@@ -1,7 +1,8 @@
-import { PostgresNotifListenManager, PrglNotifListener } from "./PostgresNotifListenManager";
-import { DB, PGP } from "./Prostgles";
+import type { PrglNotifListener } from "./PostgresNotifListenManager";
+import { PostgresNotifListenManager } from "./PostgresNotifListenManager";
+import type { DB, PGP } from "./Prostgles";
 import { getKeys, CHANNELS } from "prostgles-types";
-import { PRGLIOSocket } from "./DboBuilder/DboBuilder";
+import type { PRGLIOSocket } from "./DboBuilder/DboBuilder";
 
 export class DBEventsManager {
   notifies: {

package/lib/DBSchemaBuilder/DBSchemaBuilder.spec.ts

@@ -0,0 +1,128 @@
+import { describe, test } from "node:test";
+import type { DBOFullyTyped, PublishFullyTyped } from "./DBSchemaBuilder";
+import type { PublishParams } from "../PublishParser/publishTypesAndUtils";
+import prostgles from "..";
+import type { AuthConfig } from "../Auth/AuthTypes";
+import type { DBSchema } from "prostgles-types";
+import type { DBHandlerServer } from "../Prostgles";
+
+void describe("DBSchemaBuilder type tests", async () => {
+  await test("Type checks", () => {
+    /** Type checks */
+    () => {
+      const ddb = {} as DBOFullyTyped;
+      ddb.dwad?.insert;
+      ddb.dwad?.delete;
+
+      const d = {} as DBOFullyTyped<undefined>;
+      d.dwad?.insert;
+      d.dwad?.delete;
+
+      const p = {} as PublishParams;
+      p.dbo.dwad?.insert;
+      ddb.dwad?.delete;
+
+      //@ts-ignore
+      void prostgles({
+        dbConnection: "",
+        publish: async (params) => {
+          const _rows = await params.dbo.dwadwa?.find?.({});
+
+          return "*" as const;
+        },
+        transactions: true,
+        onReady: ({ dbo }) => {
+          void dbo.tdwa?.find!();
+          void dbo.tx((t) => {
+            void t.dwa?.find!();
+          });
+        },
+      });
+
+      const _auth: AuthConfig = {
+        sidKeyName: "sid_token",
+        getUser: (sid, db, _db) => {
+          db.dwadaw?.find;
+          return {};
+        },
+      };
+
+      type S = {
+        tbl1: {
+          columns: {
+            col1: number | null;
+            col2: string;
+          };
+        };
+        tbl2: {
+          columns: {
+            col1: number | null;
+            col2: string;
+          };
+        };
+      };
+
+      /** Test the created schema */
+      const c = {} as S;
+      const _test: DBSchema = c;
+      const dbt = {} as DBOFullyTyped<S>;
+
+      void dbt.tx((t) => {
+        void t.tbl1.delete();
+      });
+
+      const db = {} as DBHandlerServer;
+      void db.tx!((t) => {
+        void t.wadwa?.find!();
+      });
+
+      const _publish = (): PublishFullyTyped<S> => {
+        const r = {
+          tbl1: {
+            select: {
+              fields: "*" as const,
+              forcedFilter: { col1: 32, col2: "" },
+            },
+            getColumns: true,
+            getInfo: true,
+            delete: {
+              filterFields: { col1: 1 },
+            },
+          },
+          tbl2: {
+            delete: {
+              filterFields: "*" as const,
+              forcedFilter: { col1: 2 },
+            },
+          },
+        };
+        const res: PublishFullyTyped<S> = {
+          tbl1: {
+            select: {
+              fields: "*",
+              forcedFilter: { col1: 32, col2: "" },
+            },
+            getColumns: true,
+            getInfo: true,
+            delete: {
+              filterFields: { col1: 1 },
+            },
+          },
+          tbl2: {
+            delete: {
+              filterFields: "*" as const,
+              forcedFilter: { col1: 2 },
+            },
+          },
+        };
+        const _res1: PublishFullyTyped = r;
+
+        const p = {} as PublishParams<undefined>;
+
+        void p.dbo.dwadaw?.find?.();
+
+        return res;
+      };
+    };
+  });
+});

package/lib/DBSchemaBuilder/DBSchemaBuilder.ts

@@ -0,0 +1,100 @@
+import type {
+  AnyObject,
+  DbJoinMaker,
+  DBSchema,
+  SQLHandler,
+  TableHandler,
+  TableSchema,
+  ViewHandler,
+} from "prostgles-types";
+import type { TX } from "../DboBuilder/DboBuilderTypes";
+import type {
+  PublishAllOrNothing,
+  PublishTableRule,
+  PublishViewRule,
+} from "../PublishParser/PublishParser";
+import { type PublishObject } from "../PublishParser/PublishParser";
+import type { TableConfig } from "../TableConfig/TableConfig";
+import { escapeTSNames } from "../utils/utils";
+import { getColumnTypescriptDefinition } from "./getColumnTypescriptDefinition";
+
+export const getDBSchema = ({
+  tablesOrViews,
+  config,
+}: {
+  tablesOrViews: TableSchema[];
+  config: TableConfig | undefined;
+}): string => {
+  const tables: string[] = [];
+
+  /** Tables and columns are sorted to avoid infinite loops due to changing order */
+  tablesOrViews
+    .slice(0)
+    .sort((a, b) => a.name.localeCompare(b.name))
+    .forEach((tableOrView) => {
+      const { privileges, columns } = tableOrView;
+      const cols = columns.slice(0).sort((a, b) => a.name.localeCompare(b.name));
+      tables.push(`${escapeTSNames(tableOrView.name)}: {
+    is_view: ${tableOrView.is_view};
+    select: ${privileges.select};
+    insert: ${privileges.insert};
+    update: ${privileges.update};
+    delete: ${privileges.delete};
+    columns: {${cols
+      .map(
+        (column) => `
+      ${getColumnTypescriptDefinition({ tablesOrViews, config, tableOrView, column })}`
+      )
+      .join("")}
+    };
+  };\n  `);
+    });
+  return `
+export type DBGeneratedSchema = {
+  ${tables.join("")}
+}
+`;
+};
+
+export type ServerViewHandler<
+  T extends AnyObject = AnyObject,
+  Schema extends DBSchema | void = void,
+> = ViewHandler<T, Schema> & { is_view: true };
+export type ServerTableHandler<
+  T extends AnyObject = AnyObject,
+  Schema extends DBSchema | void = void,
+> = TableHandler<T, Schema> & { is_view: false };
+
+export type DBTableHandlersFromSchema<Schema = void> =
+  Schema extends DBSchema ?
+    {
+      [tov_name in keyof Schema]: Schema[tov_name]["is_view"] extends true ?
+        ServerViewHandler<Schema[tov_name]["columns"], Schema>
+      : ServerTableHandler<Schema[tov_name]["columns"], Schema>;
+    }
+  : Record<string, Partial<ServerTableHandler>>;
+
+export type DBHandlerServerExtra<
+  TH = Record<string, Partial<ServerTableHandler>>,
+  WithTransactions = true,
+> = {
+  sql: SQLHandler;
+} & Partial<DbJoinMaker> &
+  (WithTransactions extends true ? { tx: TX<TH> } : Record<string, never>);
+
+export type DBOFullyTyped<
+  Schema = void,
+  WithTransactions = true,
+> = DBTableHandlersFromSchema<Schema> &
+  DBHandlerServerExtra<DBTableHandlersFromSchema<Schema>, WithTransactions>;
+
+export type PublishFullyTyped<Schema = void> =
+  Schema extends DBSchema ?
+    {
+      [tov_name in keyof Partial<Schema>]:
+        | PublishAllOrNothing
+        | (Schema[tov_name]["is_view"] extends true ?
+            PublishViewRule<Schema[tov_name]["columns"], Schema>
+          : PublishTableRule<Schema[tov_name]["columns"], Schema>);
+    }
+  : PublishObject;

package/lib/DBSchemaBuilder/getColumnTypescriptDefinition.ts

@@ -0,0 +1,117 @@
+import {
+  getJSONBSchemaTSTypes,
+  isDefined,
+  isObject,
+  postgresToTsType,
+  type JSONB,
+  type TableSchema,
+} from "prostgles-types";
+import type { TableSchemaColumn } from "../DboBuilder/DboBuilder";
+import { escapeTSNames } from "../utils/utils";
+import type { TableConfig } from "../TableConfig/TableConfig";
+import { getColumnConfig } from "../TableConfig/getColumnConfig";
+
+export const getColumnTypescriptDefinition = ({
+  config,
+  tablesOrViews,
+  tableOrView,
+  column,
+}: {
+  config: TableConfig | undefined;
+  tablesOrViews: TableSchema[];
+  tableOrView: TableSchema;
+  column: TableSchema["columns"][number];
+}) => {
+  /**
+   * Columns that are nullable or have default values can be ommitted from an insert
+   * Non nullable columns with default values cannot containt null values in an insert so they must contain a valid value or be omitted
+   */
+
+  const dataType = getDataType({
+    config,
+    tablesOrViews,
+    tableOrView,
+    column,
+  });
+  const { name, is_nullable, has_default } = column;
+
+  return `${escapeTSNames(name)}${is_nullable || has_default ? "?" : ""}: ${dataType}`;
+};
+
+export const getDataType = ({
+  config,
+  tablesOrViews,
+  tableOrView,
+  column,
+}: {
+  config: TableConfig | undefined;
+  tablesOrViews: TableSchema[];
+  tableOrView: TableSchema;
+  column: TableSchema["columns"][number];
+}) => {
+  const typeFromUdtName: string =
+    (column.is_nullable ? "null | " : "") + getColTypeForDBSchema(column.udt_name) + ";";
+
+  const buildEnumTypeDefinition = (enumVals: any[] | readonly any[], nullable: boolean) => {
+    const types = enumVals.map((t) => (typeof t === "number" ? t : JSON.stringify(t)));
+    if (nullable) {
+      types.unshift("null");
+    }
+    return types.join(" | ");
+  };
+
+  const tableConfig = config && config[tableOrView.name];
+  if (tableConfig && "isLookupTable" in tableConfig && column.is_pkey) {
+    const enumValus = Object.keys(tableConfig.isLookupTable.values);
+    return buildEnumTypeDefinition(enumValus, !!column.is_nullable);
+  }
+
+  const colConf = config && getColumnConfig(config, tableOrView.name, column.name);
+  if (!colConf || !isObject(colConf)) {
+    return typeFromUdtName;
+  }
+
+  if (colConf.jsonbSchema || colConf.jsonbSchemaType) {
+    const schema: JSONB.JSONBSchema = colConf.jsonbSchema || {
+      ...colConf,
+      type: colConf.jsonbSchemaType,
+    };
+    return getJSONBSchemaTSTypes(schema, { nullable: colConf.nullable }, "      ", tablesOrViews);
+  }
+
+  if ("enum" in colConf) {
+    if (!colConf.enum) throw "colConf.enum missing";
+    return buildEnumTypeDefinition(colConf.enum, !!colConf.nullable);
+  }
+
+  /** When referencing a isLookupTable table we add the isLookupTable.values as enums */
+  if (("references" in colConf && colConf.references) || column.references?.length) {
+    const lookupTableConfig =
+      colConf.references ?
+        config[colConf.references.tableName]
+      : column.references
+          ?.map((ref) => {
+            const refTableConfig = config[ref.ftable];
+            if (refTableConfig && "isLookupTable" in refTableConfig) {
+              return refTableConfig;
+            }
+          })
+          .find(isDefined);
+    if (lookupTableConfig && "isLookupTable" in lookupTableConfig) {
+      const enumValus = Object.keys(lookupTableConfig.isLookupTable.values);
+      return buildEnumTypeDefinition(enumValus, !!colConf.nullable);
+    }
+  }
+
+  return typeFromUdtName;
+};
+
+const getColTypeForDBSchema = (udt_name: TableSchemaColumn["udt_name"]): string => {
+  if (udt_name === "interval") {
+    const units = ["years", "months", "days", "hours", "minutes", "seconds", "milliseconds"];
+
+    return `{ ${units.map((u) => `${u}?: number;`).join(" ")} }`;
+  }
+
+  return postgresToTsType(udt_name);
+};

package/lib/DboBuilder/DboBuilder.ts

@@ -3,9 +3,8 @@
  *  Licensed under the MIT License. See LICENSE in the project root for license information.
  *--------------------------------------------------------------------------------------------*/
 
+import type { PG_COLUMN_UDT_DATA_TYPE, SQLOptions } from "prostgles-types";
 import {
-  PG_COLUMN_UDT_DATA_TYPE,
-  SQLOptions,
   getJSONBTSTypes,
   getJoinHandlers,
   getObjectEntries,
@@ -14,16 +13,17 @@ import {
   tryCatchV2,
   type JSONB,
 } from "prostgles-types";
-import { getDBSchema } from "../DBSchemaBuilder";
-import { DB, Prostgles } from "../Prostgles";
-import { Join } from "../ProstglesTypes";
+import { getDBSchema } from "../DBSchemaBuilder/DBSchemaBuilder";
+import type { DB, Prostgles } from "../Prostgles";
+import type { Join } from "../ProstglesTypes";
 import { PubSubManager } from "../PubSubManager/PubSubManager";
 import { getCreatePubSubManagerError } from "../PubSubManager/getCreatePubSubManagerError";
-import { DbTableInfo, getV2Methods, PublishParser } from "../PublishParser/PublishParser";
+import type { DbTableInfo, PublishParser } from "../PublishParser/PublishParser";
+import { getV2Methods } from "../PublishParser/PublishParser";
 import { getQueryErrorPositionInfo } from "../TableConfig/runSQLFile";
-import { Graph } from "../shortestPath";
-import { clone } from "../utils";
-import {
+import type { Graph } from "../shortestPath";
+import { clone } from "../utils/utils";
+import type {
   DBHandlerServer,
   DbTxTableHandlers,
   LocalParams,
@@ -32,10 +32,11 @@ import {
 } from "./DboBuilderTypes";
 import { QueryStreamer } from "./QueryStreamer";
 import { TableHandler } from "./TableHandler/TableHandler";
-import { JoinPaths, ViewHandler } from "./ViewHandler/ViewHandler";
+import type { JoinPaths } from "./ViewHandler/ViewHandler";
+import { ViewHandler } from "./ViewHandler/ViewHandler";
 import { parseJoinPath } from "./ViewHandler/parseJoinPath";
+import type { PGConstraint } from "./dboBuilderUtils";
 import {
-  PGConstraint,
   getCanExecute,
   getConstraints,
   getSerializedClientErrorFromPGError,
@@ -240,7 +241,8 @@ export class DboBuilder {
       data: tablesOrViewsReq.durations,
       duration: Date.now() - start,
     });
-    this.tablesOrViews = tablesOrViewsReq.result;
+    const tablesOrViews = tablesOrViewsReq.result;
+    this.tablesOrViews = tablesOrViews;
 
     this.constraints = await getConstraints(this.db, this.prostgles.opts.schemaFilter);
     await this.prepareShortestJoinPaths();
@@ -301,7 +303,7 @@ export class DboBuilder {
     const v2Methods = getV2Methods(this.prostgles.opts.publishMethods);
     if (v2Methods) {
       const methodDefinitions = getObjectEntries(v2Methods).map(([name, method]) => {
-        const argumentTypes = getJSONBTSTypes(this.tablesOrViews ?? [], {
+        const argumentTypes = getJSONBTSTypes(tablesOrViews, {
           type: method.input as JSONB.ObjectType["type"],
         });
 
@@ -309,7 +311,7 @@ export class DboBuilder {
           v.trim().endsWith(";") ? v.trim().slice(0, -1) : v.trim();
         const returnType =
           !method.output ? "void" : (
-            getJSONBTSTypes(this.tablesOrViews ?? [], {
+            getJSONBTSTypes(tablesOrViews, {
               type: method.output as JSONB.ObjectType["type"],
             })
           );
@@ -329,7 +331,10 @@ export class DboBuilder {
 
     this.tsTypesDefinition = [
       `/* Schema definition generated by prostgles-server */`,
-      getDBSchema(this),
+      getDBSchema({
+        config: this.prostgles.opts.tableConfig,
+        tablesOrViews,
+      }),
       functionTypes,
     ].join("\n");
 

package/lib/DboBuilder/DboBuilderTypes.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as pgPromise from "pg-promise";
-import {
+import type {
   AnyObject,
   ClientSchema,
   ColumnInfo,
@@ -15,12 +15,12 @@ import {
   TableInfo as TInfo,
   UserLike,
 } from "prostgles-types";
-import { AuthClientRequest, BasicSession, SessionUser } from "../Auth/AuthTypes";
-import { BasicCallback } from "../PubSubManager/PubSubManager";
-import { PublishAllOrNothing } from "../PublishParser/PublishParser";
-import { FieldSpec } from "./QueryBuilder/Functions";
-import { TableHandler } from "./TableHandler/TableHandler";
-import { ParsedJoinPath } from "./ViewHandler/parseJoinPath";
+import type { AuthClientRequest, BasicSession, SessionUser } from "../Auth/AuthTypes";
+import type { BasicCallback } from "../PubSubManager/PubSubManager";
+import type { PublishAllOrNothing } from "../PublishParser/PublishParser";
+import type { FieldSpec } from "./QueryBuilder/Functions/Functions";
+import type { TableHandler } from "./TableHandler/TableHandler";
+import type { ParsedJoinPath } from "./ViewHandler/parseJoinPath";
 import pg = require("pg-promise/typescript/pg-subset");
 
 type PGP = pgPromise.IMain<{}, pg.IClient>;

package/lib/DboBuilder/QueryBuilder/Functions/COMPUTED_FIELDS.ts

@@ -0,0 +1,35 @@
+import { asNameAlias } from "../../../utils/asNameAlias";
+import type { FieldSpec } from "./Functions";
+/* The difference between a function and computed field is that the computed field does not require any arguments */
+export const COMPUTED_FIELDS: FieldSpec[] = [
+  /**
+   * Used instead of row id. Must be used as a last resort. Use all non pseudo or domain data type columns first!
+   */
+  {
+    name: "$rowhash",
+    type: "computed",
+    // description: ` order hash of row content  `,
+    getQuery: ({ allowedFields, tableAlias, ctidField }) => {
+      return (
+        "md5(" +
+        allowedFields
+
+          /* CTID not available in AFTER trigger */
+          // .concat(ctidField? [ctidField] : [])
+          .sort()
+          .map((f) => asNameAlias(f, tableAlias))
+          .map((f) => `md5(coalesce(${f}::text, 'dd'))`)
+          .join(" || ") +
+        `)`
+      );
+    },
+  },
+  // ,{
+  //   name: "ctid",
+  //   type: "computed",
+  //   // description: ` order hash of row content  `,
+  //   getQuery: ({ allowedFields, tableAlias, ctidField }) => {
+  //     return asNameAlias("ctid", tableAlias);
+  //   }
+  // }
+];

package/lib/DboBuilder/QueryBuilder/{Functions.ts → Functions/Functions.ts}

@@ -1,78 +1,16 @@
+import type { ColumnInfo, PG_COLUMN_UDT_DATA_TYPE } from "prostgles-types";
 import {
   asName,
-  ColumnInfo,
   includes,
   isEmpty,
   isObject,
-  PG_COLUMN_UDT_DATA_TYPE,
   TextFilter_FullTextSearchFilterKeys,
+  postgresToTsType,
 } from "prostgles-types";
-import { isPlainObject, pgp, postgresToTsType } from "../DboBuilder";
-import { parseFieldFilter } from "../ViewHandler/parseFieldFilter";
-import { asNameAlias } from "./QueryBuilder";
-
-export const parseFunction = (funcData: {
-  func: string | FunctionSpec;
-  args: any[];
-  functions: FunctionSpec[];
-  allowedFields: string[];
-}): FunctionSpec => {
-  const { func, args, functions, allowedFields } = funcData;
-
-  /* Function is computed column. No checks needed */
-  if (typeof func !== "string") {
-    const computedCol = COMPUTED_FIELDS.find((c) => c.name === func.name);
-    if (!computedCol)
-      throw `Unexpected function: computed column spec not found for ${JSON.stringify(func.name)}`;
-    return func;
-  }
-
-  const funcName = func;
-  const makeErr = (msg: string): string => {
-    return `Issue with function ${JSON.stringify({ [funcName]: args })}: \n${msg}`;
-  };
-
-  /* Find function */
-  const funcDef = functions.find((f) => f.name === funcName);
-
-  if (!funcDef) {
-    const sf = functions
-      .filter((f) => f.name.toLowerCase().slice(1).startsWith(funcName.toLowerCase()))
-      .sort((a, b) => a.name.length - b.name.length);
-    const hint =
-      sf.length ?
-        `. \n Maybe you meant: \n | ${sf.map((s) => s.name + " " + (s.description || "")).join("    \n | ")}  ?`
-      : "";
-    throw "\n Function " + funcName + " does not exist or is not allowed " + hint;
-  }
-
-  /* Validate fields */
-  const fields = funcDef.getFields(args);
-  if (fields !== "*") {
-    fields.forEach((fieldKey) => {
-      if (typeof fieldKey !== "string" || !allowedFields.includes(fieldKey)) {
-        throw makeErr(
-          `getFields() => field name ${JSON.stringify(fieldKey)} is invalid or disallowed`
-        );
-      }
-    });
-    if ((funcDef.minCols ?? 0) > fields.length) {
-      throw makeErr(`Less columns provided than necessary (minCols=${funcDef.minCols})`);
-    }
-  }
-
-  if (
-    funcDef.numArgs &&
-    funcDef.minCols !== 0 &&
-    fields !== "*" &&
-    Array.isArray(fields) &&
-    !fields.length
-  ) {
-    throw `\n Function "${funcDef.name}" expects at least a field name but has not been provided with one`;
-  }
-
-  return funcDef;
-};
+import { parseFieldFilter } from "../../ViewHandler/parseFieldFilter";
+import * as pgPromise from "pg-promise";
+import { asNameAlias } from "../../../utils/asNameAlias";
+const pgp = pgPromise();
 
 type GetQueryArgs = {
   allColumns: ColumnInfo[];
@@ -284,7 +222,7 @@ const FTS_Funcs: FunctionSpec[] =
       const searchTypes = TextFilter_FullTextSearchFilterKeys;
 
       /* { to_tsquery: 'search term' } */
-      if (isPlainObject(qVal)) {
+      if (isObject(qVal)) {
         const keys = Object.keys(qVal);
         if (!keys.length) throw "Bad arg";
         if (keys.length !== 1 || !searchTypes.includes(keys[0] as any))
@@ -1274,40 +1212,6 @@ export const FUNCTIONS: FunctionSpec[] = [
   } as FunctionSpec,
 ];
 
-/* The difference between a function and computed field is that the computed field does not require any arguments */
-export const COMPUTED_FIELDS: FieldSpec[] = [
-  /**
-   * Used instead of row id. Must be used as a last resort. Use all non pseudo or domain data type columns first!
-   */
-  {
-    name: "$rowhash",
-    type: "computed",
-    // description: ` order hash of row content  `,
-    getQuery: ({ allowedFields, tableAlias, ctidField }) => {
-      return (
-        "md5(" +
-        allowedFields
-
-          /* CTID not available in AFTER trigger */
-          // .concat(ctidField? [ctidField] : [])
-          .sort()
-          .map((f) => asNameAlias(f, tableAlias))
-          .map((f) => `md5(coalesce(${f}::text, 'dd'))`)
-          .join(" || ") +
-        `)`
-      );
-    },
-  },
-  // ,{
-  //   name: "ctid",
-  //   type: "computed",
-  //   // description: ` order hash of row content  `,
-  //   getQuery: ({ allowedFields, tableAlias, ctidField }) => {
-  //     return asNameAlias("ctid", tableAlias);
-  //   }
-  // }
-];
-
 /*