prostgles-server 4.2.344 → 4.2.346

package/lib/Auth/endpoints/setMagicLinkOrOTPRequestHandler.ts

@@ -1,16 +1,18 @@
-import e, { type Response } from "express";
-import { DBOFullyTyped } from "../../DBSchemaBuilder";
+import type e from "express";
+import { type Response } from "express";
+import type { DBOFullyTyped } from "../../DBSchemaBuilder/DBSchemaBuilder";
+import type {
+  AuthHandler} from "../AuthHandler";
 import {
   AUTH_ROUTES_AND_PARAMS,
-  AuthHandler,
   getClientRequestIPsInfo,
   HTTP_FAIL_CODES,
   HTTP_SUCCESS_CODES,
 } from "../AuthHandler";
-import { ExpressReq, LoginSignupConfig, MagicLinkOrOTPData, SessionUser } from "../AuthTypes";
+import type { ExpressReq, LoginSignupConfig, MagicLinkOrOTPData, SessionUser } from "../AuthTypes";
 import { throttledAuthCall } from "../utils/throttledReject";
-import { LoginResponse } from "./setLoginRequestHandler";
-import { AuthResponse } from "prostgles-types";
+import type { LoginResponse } from "./setLoginRequestHandler";
+import type { AuthResponse } from "prostgles-types";
 
 type MagicLinkResponseHandler = Response<
   | LoginResponse

package/lib/Auth/endpoints/setOAuthRequestHandlers.ts

@@ -1,4 +1,4 @@
-import e from "express";
+import type e from "express";
 import * as passport from "passport";
 import { Strategy as FacebookStrategy } from "passport-facebook";
 import { Strategy as GitHubStrategy } from "passport-github2";
@@ -6,12 +6,13 @@ import { Strategy as GoogleStrategy } from "passport-google-oauth20";
 import { Strategy as MicrosoftStrategy } from "passport-microsoft";
 import { getObjectEntries, isEmpty } from "prostgles-types";
 import { getErrorAsObject } from "../../DboBuilder/dboBuilderUtils";
-import { DBOFullyTyped } from "../../DBSchemaBuilder";
-import { AUTH_ROUTES_AND_PARAMS, AuthHandler, HTTP_FAIL_CODES } from "../AuthHandler";
-import { AuthProviderUserData, LoginWithOAuthConfig } from "../AuthTypes";
+import type { DBOFullyTyped } from "../../DBSchemaBuilder/DBSchemaBuilder";
+import type { AuthHandler} from "../AuthHandler";
+import { AUTH_ROUTES_AND_PARAMS, HTTP_FAIL_CODES } from "../AuthHandler";
+import type { AuthProviderUserData, LoginWithOAuthConfig } from "../AuthTypes";
 import { getClientRequestIPsInfo } from "../utils/getClientRequestIPsInfo";
 import { upsertNamedExpressMiddleware } from "../utils/upsertNamedExpressMiddleware";
-import { LoginResponseHandler } from "./setLoginRequestHandler";
+import type { LoginResponseHandler } from "./setLoginRequestHandler";
 import OAuth2Strategy from "passport-oauth2";
 export function setOAuthRequestHandlers(
   this: AuthHandler,

package/lib/Auth/endpoints/setRegisterRequestHandler.ts

@@ -1,5 +1,6 @@
-import e, { Request, Response } from "express";
-import { AuthResponse } from "prostgles-types";
+import type { Request, Response } from "express";
+import type e from "express";
+import type { AuthResponse } from "prostgles-types";
 import { AUTH_ROUTES_AND_PARAMS, HTTP_FAIL_CODES } from "../AuthHandler";
 import { getMagicLinkUrl, type SignupWithEmail } from "../AuthTypes";
 import { getClientRequestIPsInfo } from "../utils/getClientRequestIPsInfo";

package/lib/Auth/getClientAuth.ts

@@ -1,19 +1,22 @@
-import {
+import type {
   AuthGuardLocation,
   AuthGuardLocationResponse,
-  AuthSocketSchema,
+  AuthSocketSchema} from "prostgles-types";
+import {
   CHANNELS,
   getObjectEntries,
   isEmpty,
   isObject,
 } from "prostgles-types";
-import {
+import type {
   AuthClientRequest,
   LoginWithOAuthConfig,
-  AuthResultWithSID,
+  AuthResultWithSID} from "./AuthTypes";
+import {
   type AuthResult,
 } from "./AuthTypes";
-import { AUTH_ROUTES_AND_PARAMS, AuthHandler } from "./AuthHandler";
+import type { AuthHandler } from "./AuthHandler";
+import { AUTH_ROUTES_AND_PARAMS } from "./AuthHandler";
 
 export async function getClientAuth(
   this: AuthHandler,

package/lib/Auth/login.ts

@@ -1,7 +1,9 @@
-import { DBOFullyTyped } from "../DBSchemaBuilder";
-import { AuthHandler, getClientRequestIPsInfo, HTTP_FAIL_CODES } from "./AuthHandler";
-import { ExpressReq, LoginParams, type BasicSession } from "./AuthTypes";
-import { LoginResponseHandler } from "./endpoints/setLoginRequestHandler";
+import type { DBOFullyTyped } from "../DBSchemaBuilder/DBSchemaBuilder";
+import type { AuthHandler} from "./AuthHandler";
+import { getClientRequestIPsInfo, HTTP_FAIL_CODES } from "./AuthHandler";
+import type { ExpressReq, LoginParams} from "./AuthTypes";
+import { type BasicSession } from "./AuthTypes";
+import type { LoginResponseHandler } from "./endpoints/setLoginRequestHandler";
 import { throttledAuthCall } from "./utils/throttledReject";
 
 export async function login(

package/lib/Auth/sendEmail.ts

@@ -1,7 +1,7 @@
-import { Email, SMTPConfig } from "./AuthTypes";
+import type { Email, SMTPConfig } from "./AuthTypes";
 import * as nodemailer from "nodemailer";
 import * as aws from "@aws-sdk/client-ses";
-import SESTransport from "nodemailer/lib/ses-transport";
+import type SESTransport from "nodemailer/lib/ses-transport";
 import { checkDmarc } from "./utils/checkDmarc";
 
 type SESTransporter = nodemailer.Transporter<SESTransport.SentMessageInfo, SESTransport.Options>;

package/lib/Auth/setupAuthRoutes.ts

@@ -1,5 +1,6 @@
-import { RequestHandler } from "express";
-import { AuthHandler, getClientRequestIPsInfo } from "./AuthHandler";
+import type { RequestHandler } from "express";
+import type { AuthHandler} from "./AuthHandler";
+import { getClientRequestIPsInfo } from "./AuthHandler";
 import { setCatchAllRequestHandler } from "./endpoints/setCatchAllRequestHandler";
 import { setLoginRequestHandler } from "./endpoints/setLoginRequestHandler";
 import { setLogoutRequestHandler } from "./endpoints/setLogoutRequestHandler";

package/lib/Auth/utils/getClientRequestIPsInfo.ts

@@ -1,5 +1,5 @@
-import { PRGLIOSocket } from "../../DboBuilder/DboBuilderTypes";
-import { ExpressReq, LoginClientInfo } from "../AuthTypes";
+import type { PRGLIOSocket } from "../../DboBuilder/DboBuilderTypes";
+import type { ExpressReq, LoginClientInfo } from "../AuthTypes";
 type ClientReq =
   | { socket: PRGLIOSocket; httpReq?: undefined }
   | { httpReq: ExpressReq; socket?: undefined };

package/lib/Auth/utils/getReturnUrl.ts

@@ -1,5 +1,5 @@
 import { AUTH_ROUTES_AND_PARAMS } from "../AuthHandler";
-import { ExpressReq } from "../AuthTypes";
+import type { ExpressReq } from "../AuthTypes";
 import { getSafeReturnURL } from "./getSafeReturnURL";
 
 export const getReturnUrl = (req: ExpressReq) => {

package/lib/Auth/utils/getSidAndUserFromRequest.ts

@@ -1,6 +1,6 @@
 import { isObject } from "prostgles-types";
-import { AuthHandler } from "../AuthHandler";
-import { AuthClientRequest } from "../AuthTypes";
+import type { AuthHandler } from "../AuthHandler";
+import type { AuthClientRequest } from "../AuthTypes";
 import type { GetUserOrRedirected } from "./handleGetUser";
 
 export async function getSidAndUserFromRequest(

package/lib/Auth/utils/handleGetUser.ts

@@ -1,5 +1,6 @@
-import { AuthResponse, isObject } from "prostgles-types";
-import type { DBOFullyTyped } from "../../DBSchemaBuilder";
+import type { AuthResponse} from "prostgles-types";
+import { isObject } from "prostgles-types";
+import type { DBOFullyTyped } from "../../DBSchemaBuilder/DBSchemaBuilder";
 import { getClientRequestIPsInfo, type AuthHandler } from "../AuthHandler";
 import type { AuthClientRequest, AuthResultOrError, AuthResultWithSID } from "../AuthTypes";
 import { throttledAuthCall } from "./throttledReject";

package/lib/Auth/utils/matchesRoute.ts

@@ -0,0 +1,6 @@
+export const matchesRoute = (baseRoute: string, fullRoute: string) => {
+  if (!baseRoute || !fullRoute) return false;
+  if (baseRoute === fullRoute) return true;
+  const nextChar = fullRoute[baseRoute.length] ?? "";
+  return fullRoute.startsWith(baseRoute) && ["/", "?", "#"].includes(nextChar);
+};

package/lib/Auth/utils/removeExpressRoute.ts

@@ -1,7 +1,7 @@
 import { isDefined } from "prostgles-types";
 import type { ExpressApp } from "../../RestApi";
-import { matchesRoute } from "../AuthHandler";
-import { Express } from "express";
+import type { Express } from "express";
+import { matchesRoute } from "./matchesRoute";
 
 const getRouter = (app: ExpressApp | Express) => {
   const router = (app._router || app.router) as ExpressApp["_router"] | undefined;

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,118 @@
+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 { is_nullable } = column;
+  const typeFromUdtName: string =
+    (is_nullable ? "null | " : "") + getColTypeForDBSchema(column.udt_name) + ";";
+
+  const buildEnumTypeDefinition = (enumVals: any[] | readonly any[]) => {
+    const types = enumVals.map((t) => (typeof t === "number" ? t : JSON.stringify(t)));
+    if (is_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);
+  }
+
+  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);
+  }
+
+  /** 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);
+    }
+  }
+
+  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);
+};