prostgles-server 4.2.157 → 4.2.159

package/lib/Auth/setupAuthRoutes.ts

@@ -1,161 +0,0 @@
-import { RequestHandler } from "express";
-import { DBOFullyTyped } from "../DBSchemaBuilder";
-import { AUTH_ROUTES_AND_PARAMS, AuthHandler, getLoginClientInfo, HTTPCODES } from "./AuthHandler";
-import { AuthClientRequest, ExpressReq, ExpressRes, LoginParams } from "./AuthTypes";
-import { setAuthProviders, upsertNamedExpressMiddleware } from "./setAuthProviders";
-
-export async function setupAuthRoutes(this: AuthHandler) {
-  if (!this.opts) return;
- 
-  const { login, getUser, expressConfig } = this.opts;
-
-  if (!login) {
-    throw "Invalid auth: Provide { sidKeyName: string } ";
-  }
-
-  if (this.sidKeyName === "sid") {
-    throw "sidKeyName cannot be 'sid' due to collision with socket.io";
-  }
-
-  if (!getUser) throw "getUser missing from auth config";
-
-  if (!expressConfig) {
-    return 
-  }
-  const { app, publicRoutes = [], onGetRequestOK, magicLinks, use } = expressConfig;
-  if (publicRoutes.find(r => typeof r !== "string" || !r)) {
-    throw "Invalid or empty string provided within publicRoutes "
-  }
-
-  setAuthProviders.bind(this)(expressConfig);
-
-  if(use){
-    const prostglesUseMiddleware: RequestHandler = (req, res, next) => {
-      use({ 
-        req, 
-        res, 
-        next, 
-        getUser: () => this.getUser({ httpReq: req }) as any,
-        dbo: this.dbo as DBOFullyTyped, 
-        db: this.db,
-      })
-    };
-    upsertNamedExpressMiddleware(app, prostglesUseMiddleware, "prostglesUseMiddleware");
-  }
-
-  if (magicLinks) {
-    const { check } = magicLinks;
-    if (!check) {
-      throw "Check must be defined for magicLinks";
-    }
-
-    app.get(AUTH_ROUTES_AND_PARAMS.magicLinksExpressRoute, async (req: ExpressReq, res: ExpressRes) => {
-      const { id } = req.params ?? {};
-
-      if (typeof id !== "string" || !id) {
-        res.status(HTTPCODES.BAD_REQUEST).json({ msg: "Invalid magic-link id. Expecting a string" });
-      } else {
-        try {
-          const session = await this.throttledFunc(async () => {
-            return check(id, this.dbo as any, this.db, getLoginClientInfo({ httpReq: req }));
-          });
-          if (!session) {
-            res.status(HTTPCODES.AUTH_ERROR).json({ msg: "Invalid magic-link" });
-          } else {
-            this.setCookieAndGoToReturnURLIFSet(session, { req, res });
-          }
-
-        } catch (e) {
-          res.status(HTTPCODES.AUTH_ERROR).json({ msg: e });
-        }
-      }
-    });
-  }
-
-  app.post(AUTH_ROUTES_AND_PARAMS.login, async (req: ExpressReq, res: ExpressRes) => {
-    try {
-      const loginParams: LoginParams = {
-        type: "username",
-        ...req.body,
-      };
-
-      await this.loginThrottledAndSetCookie(req, res, loginParams);
-    } catch (err) {
-      console.log(err)
-      res.status(HTTPCODES.AUTH_ERROR).json({ err });
-    }
-
-  });
-
-  const onLogout = async (req: ExpressReq, res: ExpressRes) => {
-    const sid = this.validateSid(req?.cookies?.[this.sidKeyName]);
-    if (sid) {
-      try {
-        await this.throttledFunc(() => {
-          return this.opts?.logout?.(req?.cookies?.[this.sidKeyName], this.dbo as any, this.db);
-        })
-      } catch (err) {
-        console.error(err);
-      }
-    }
-    res.redirect("/")
-  }
-  
-  /* Redirect if not logged in and requesting non public content */
-  app.get(AUTH_ROUTES_AND_PARAMS.catchAll, async (req: ExpressReq, res: ExpressRes, next) => {
-
-    const clientReq: AuthClientRequest = { httpReq: req };
-    const getUser = this.getUser;
-    if(this.prostgles.restApi){
-      if(Object.values(this.prostgles.restApi.routes).some(restRoute => this.matchesRoute(restRoute.split("/:")[0], req.path))){
-        next();
-        return;
-      }
-    }
-    try {
-      const returnURL = this.getReturnUrl(req);
-      
-      if(this.matchesRoute(AUTH_ROUTES_AND_PARAMS.logoutGetPath, req.path)){
-        await onLogout(req, res);
-        return;
-      }
-
-      if(this.matchesRoute(AUTH_ROUTES_AND_PARAMS.loginWithProvider, req.path)){
-        next();
-        return;
-      }
-      /**
-       * Requesting a User route
-       */
-      if (this.isUserRoute(req.path)) {
-
-        /* Check auth. Redirect to login if unauthorized */
-        const u = await getUser(clientReq);
-        if (!u) {
-          res.redirect(`${AUTH_ROUTES_AND_PARAMS.login}?returnURL=${encodeURIComponent(req.originalUrl)}`);
-          return;
-        }
-
-        /* If authorized and going to returnUrl then redirect. Otherwise serve file */
-      } else if (returnURL && (await getUser(clientReq))) {
-
-        res.redirect(returnURL);
-        return;
-
-        /** If Logged in and requesting login then redirect to main page */
-      } else if (this.matchesRoute(AUTH_ROUTES_AND_PARAMS.login, req.path) && (await getUser(clientReq))) {
-
-        res.redirect("/");
-        return;
-      }
-
-      onGetRequestOK?.(req, res, { getUser: () => getUser(clientReq), dbo: this.dbo as DBOFullyTyped, db: this.db })
-
-    } catch (error) {
-      console.error(error);
-      const errorMessage = typeof error === "string" ? error : error instanceof Error ? error.message : "";
-      res.status(HTTPCODES.AUTH_ERROR).json({ msg: "Something went wrong when processing your request" + (errorMessage? (": " + errorMessage) : "") });
-    }
-
-  });
-}

package/lib/DBEventsManager.ts

@@ -1,178 +0,0 @@
-import { PostgresNotifListenManager, PrglNotifListener } from "./PostgresNotifListenManager";
-import { DB, PGP } from "./Prostgles";
-import { getKeys, CHANNELS } from "prostgles-types";
-import { PRGLIOSocket } from "./DboBuilder/DboBuilder";
-
-export class DBEventsManager {
-
-  notifies: { 
-    [key: string]: {
-      socketChannel: string;
-      sockets: any[]; 
-      localFuncs: ((payload: string) => void)[];
-      notifMgr: PostgresNotifListenManager;
-    } 
-  } = {};
-
-  notice: {
-    socketChannel: string;
-    socketUnsubChannel: string;
-    sockets: any[];
-  } = {
-    socketChannel: CHANNELS.NOTICE_EV,
-    socketUnsubChannel: CHANNELS.NOTICE_EV + "unsubscribe",
-    sockets: []
-  };
-
-  notifManager?: PostgresNotifListenManager;
-
-  db_pg: DB;
-  pgp: PGP
-  constructor(db_pg: DB, pgp: PGP){
-    this.db_pg = db_pg;
-    this.pgp = pgp;
-  }
-
-  private onNotif: PrglNotifListener = ({ channel, payload }) => {
-
-    // console.log(36, { channel, payload },  Object.keys(this.notifies));
-
-    getKeys(this.notifies)
-      .filter(ch => ch === channel)
-      .map(ch => {
-        const sub = this.notifies[ch]!;
-        
-        sub.sockets.map(s => {
-          s.emit(sub.socketChannel, payload)
-        });
-        sub.localFuncs.map(lf => {
-          lf(payload);
-        })
-      });
-  }
-
-  onNotice = (notice: any) => {
-    if(this.notice && this.notice.sockets.length){
-      this.notice.sockets.map(s => {
-        s.emit(this.notice.socketChannel, notice);
-      })
-    }
-  }
-
-  getNotifChannelName = async (channel: string) => {
-    const c = await this.db_pg.one("SELECT quote_ident($1) as c", channel);
-    return c.c;
-  }
-
-  async addNotify(query: string, socket?: PRGLIOSocket, func?: any): Promise<{
-    socketChannel: string;
-    socketUnsubChannel: string;
-    notifChannel: string;
-    unsubscribe?: () => void;
-  }> {
-    if(typeof query !== "string" || (!socket && !func)){
-      throw "Expecting (query: string, socket?, localFunc?) But received: " + JSON.stringify({ query, socket, func });
-    }
-
-    /* Remove comments */
-    let q = query.trim()
-      .replace(/\/\*[\s\S]*?\*\/|\/\/.*/g,'\n')
-      .split("\n").map(v => v.trim()).filter(v => v && !v.startsWith("--"))
-      .join("\n");
-
-    /* Find the notify channel name */
-    if(!q.toLowerCase().startsWith("listen")){
-      throw "Expecting a LISTEN query but got: " + query;
-    }
-    q = q.slice(7).trim(); // Remove listen
-    if(q.endsWith(";")) q = q.slice(0, -1);
-
-    if(q.startsWith('"') && q.endsWith('"')) {
-      q = q.slice(1, -1);
-    } else {
-      /* Replicate PG by lowercasing identifier if not quoted */
-      q = q.toLowerCase();
-    }
-    q = q.replace(/""/g, `"`);
-
-    const channel = q;    
-    let notifChannel = await this.getNotifChannelName(channel)
-
-    notifChannel = notifChannel.replace(/""/g, `"`);
-    if(notifChannel.startsWith('"')) notifChannel = notifChannel.slice(1, -1);
-
-    const socketChannel = CHANNELS.LISTEN_EV + notifChannel,
-      socketUnsubChannel = socketChannel + "unsubscribe";
-
-    if(!this.notifies[notifChannel]){
-      this.notifies[notifChannel] = {
-        socketChannel,
-        sockets: socket? [socket] : [],
-        localFuncs: func? [func] : [],
-        notifMgr: await PostgresNotifListenManager.create(this.db_pg, this.onNotif, channel)
-      }
-
-    } else {
-      if(socket && !this.notifies[notifChannel]!.sockets.find(s => s.id === socket.id)) {
-        this.notifies[notifChannel]!.sockets.push(socket);
-
-      } else if(func) {
-        this.notifies[notifChannel]!.localFuncs.push(func);
-      }
-    }
-
-    if(socket){
-      socket.removeAllListeners(socketUnsubChannel);
-      socket.on(socketUnsubChannel, ()=>{
-        this.removeNotify(notifChannel, socket);
-      });
-    }
-
-    return {
-      socketChannel,
-      socketUnsubChannel,
-      notifChannel,
-    }
-  }
-
-  removeNotify(channel?: string, socket?: PRGLIOSocket, func?: any){
-    const notifChannel = channel && this.notifies[channel]
-    if(notifChannel){
-      if(socket){
-        notifChannel.sockets = notifChannel.sockets.filter(s => s.id !== socket.id);
-      } else if(func){
-        notifChannel.localFuncs = notifChannel.localFuncs.filter(f => f !== func);
-      }
-
-      /* UNLISTEN if no listeners ?? */
-    }
-
-    if(socket){
-      getKeys(this.notifies).forEach(channel => {
-        this.notifies[channel]!.sockets = this.notifies[channel]!.sockets.filter(s => s.id !== socket.id);
-      })
-    }
-  }
-
-  addNotice(socket: PRGLIOSocket){
-    if(!socket || !socket.id) throw "Expecting a socket obj with id";
-
-    if(!this.notice.sockets.find(s => s.id === socket.id)){
-      this.notice.sockets.push(socket);
-    }
-
-    const { socketChannel, socketUnsubChannel } = this.notice;
-
-    socket.removeAllListeners(socketUnsubChannel);
-    socket.on(socketUnsubChannel, () => {
-      this.removeNotice(socket);
-    });
-
-    return { socketChannel, socketUnsubChannel, }
-  }
-
-  removeNotice(socket: PRGLIOSocket){
-    if(!socket || !socket.id) throw "Expecting a socket obj with id";
-    this.notice.sockets = this.notice.sockets.filter(s => s.id !== socket.id)
-  }
-}

package/lib/DBSchemaBuilder.ts

@@ -1,225 +0,0 @@
-import { AnyObject, DbJoinMaker, DBSchema, isObject, JSONB, SQLHandler, TableHandler, ViewHandler } from "prostgles-types";
-import prostgles from ".";
-import { Auth } from "./Auth/AuthTypes";
-import { DboBuilder, escapeTSNames, postgresToTsType } from "./DboBuilder/DboBuilder";
-import { PublishAllOrNothing, PublishParams, PublishTableRule, PublishViewRule,  } from "./PublishParser/PublishParser";
-import { getJSONBSchemaTSTypes } from "./JSONBValidation/validation";
-import { DBHandlerServer, TableSchemaColumn, TX } from "./DboBuilder/DboBuilderTypes";
-
-
-export const getDBSchema = (dboBuilder: DboBuilder): string => {
-  const tables: string[] = [];
-
-  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);
-  }
-  
-  /** Tables and columns are sorted to avoid infinite loops due to changing order */
-  dboBuilder.tablesOrViews?.slice(0).sort((a, b) => a.name.localeCompare(b.name)).forEach(tov => {
-    const cols = tov.columns.slice(0).sort((a, b) => a.name.localeCompare(b.name));
-    const getColType = (c: typeof cols[number]) => {
-
-      let type: string = (c.is_nullable? "null | " : "") + getColTypeForDBSchema(c.udt_name) + ";"
-      const colConf = dboBuilder.prostgles.tableConfigurator?.getColumnConfig(tov.name, c.name);
-      if(colConf){
-        if(isObject(colConf) && (colConf.jsonbSchema || colConf.jsonbSchemaType)){
-          const schema: JSONB.JSONBSchema = colConf.jsonbSchema || { ...colConf, type: colConf.jsonbSchemaType };
-          
-          type = getJSONBSchemaTSTypes(schema, { nullable: colConf.nullable }, "      ", dboBuilder.tablesOrViews ?? []);
-        } else if(isObject(colConf) && "enum" in colConf){
-          if(!colConf.enum) throw "colConf.enum missing"
-          const types = colConf.enum.map(t => typeof t === "number"? t : JSON.stringify(t));
-          if(colConf.nullable){
-            types.unshift("null")
-          }
-          type = types.join(" | ");
-        }
-      }
-      /**
-       * 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
-       */
-      return `${escapeTSNames(c.name)}${c.is_nullable || c.has_default? "?" : ""}: ${type}`
-    }
-tables.push(`${escapeTSNames(tov.name)}: {
-    is_view: ${tov.is_view};
-    select: ${tov.privileges.select};
-    insert: ${tov.privileges.insert};
-    update: ${tov.privileges.update};
-    delete: ${tov.privileges.delete};
-    columns: {${cols.map(c => `
-      ${getColType(c)}`).join("")}
-    };
-  };\n  `)
-  })
-return `
-export type DBSchemaGenerated = {
-  ${tables.join("")}
-}
-`;
-}
-
-type ServerViewHandler<T extends AnyObject = AnyObject, Schema extends DBSchema | void = void> = ViewHandler<T, Schema> & { is_view: boolean; }
-type ServerTableHandler<T extends AnyObject = AnyObject, Schema extends DBSchema | void = void> = TableHandler<T, Schema> & { is_view: boolean; }
-
-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> = Schema extends DBSchema? (
-//     DBTableHandlersFromSchema<Schema> & DBHandlerServerExtra<DBTableHandlersFromSchema<Schema>>
-//   ) : 
-//   DBHandlerServer;
-export type DBOFullyTyped<Schema = void> = DBTableHandlersFromSchema<Schema> & DBHandlerServerExtra<DBTableHandlersFromSchema<Schema>>
-
-export type PublishFullyTyped<Schema = void> = Schema extends DBSchema? (
-  | PublishAllOrNothing 
-  | { 
-    [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>
-      );
-  }
-) : (
-  | PublishAllOrNothing 
-  | Record<string, PublishViewRule | PublishTableRule | PublishAllOrNothing>
-);
-
-
-
-/** Type checks */
-(() => {
-
-  const ddb: DBOFullyTyped = 1 as any;
-  ddb.dwad?.insert;
-  ddb.dwad?.delete;
-
-  const d: DBOFullyTyped<undefined> = 1 as any;
-  d.dwad?.insert;
-  d.dwad?.delete;
-
-  const p: PublishParams = 1 as any;
-  p.dbo.dwad?.insert;
-  ddb.dwad?.delete;
-
-  //@ts-ignore
-  prostgles({
-    dbConnection: 1 as any,
-    publish: async (params) => {
-      const _rows = await params.dbo.dwadwa?.find?.({});
-      
-      return "*" as const
-    },
-    transactions: true,
-    onReady: ({ dbo }) => {
-      dbo.tdwa?.find!();
-      dbo.tx?.(t => {
-        t.dwa?.find!();
-      })
-    }
-  });
-
-
-  const _auth: Auth = {
-    sidKeyName: "sid_token",
-    getUser: async (sid, db, _db) => {
-      db.dwadaw?.find;
-      return 1 as any;
-    }
-  }
-
-
-  type S = {
-    tbl1: {
-      columns: {
-        col1: number | null;
-        col2: string; 
-      }
-    },
-    tbl2: {
-      columns: {
-        col1: number | null;
-        col2: string; 
-      }
-    }
-  }
-
-  /** Test the created schema */
-  const c: S = 1 as any;
-  const _test: DBSchema = c;
-  const dbt: DBOFullyTyped<S> = 1 as any;
-
-  dbt.tx!(t => {
-    t.tbl1.delete();
-  });
-
-  const db: DBHandlerServer = 1 as any;
-  db.tx!(t => {
-    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: PublishParams<undefined> = 1 as any;
-  
-    p.dbo.dwadaw?.find?.();
-  
-    return res;
-  }
-})