prostgles-server 4.2.133 → 4.2.135

package/lib/Auth/AuthTypes.ts

@@ -0,0 +1,247 @@
+import { Express, NextFunction, Request, Response } from "express";
+import { AnyObject, EmailSignupType, FieldFilter, UserLike } from "prostgles-types";
+import { DB } from "../Prostgles";
+import { DBOFullyTyped } from "../DBSchemaBuilder";
+import { PRGLIOSocket } from "../DboBuilder/DboBuilderTypes";
+import type { AuthenticateOptions } from "passport";
+import type { StrategyOptions as GoogleStrategy, Profile as GoogleProfile } from "passport-google-oauth20";
+import type { StrategyOptions as GitHubStrategy, Profile as GitHubProfile } from "passport-github2";
+import type { MicrosoftStrategyOptions } from "passport-microsoft";
+import type { StrategyOptions as FacebookStrategy, Profile as FacebookProfile } from "passport-facebook";
+
+type Awaitable<T> = T | Promise<T>;
+
+export type ExpressReq = Request;
+export type ExpressRes = Response;
+
+export type LoginClientInfo = {
+  ip_address: string;
+  ip_address_remote: string | undefined;
+  x_real_ip: string | undefined;
+  user_agent: string | undefined;
+};
+
+export type BasicSession = {
+
+  /** Must be hard to bruteforce */
+  sid: string;
+
+  /** UNIX millisecond timestamp */
+  expires: number;
+
+  /** On expired */
+  onExpiration: "redirect" | "show_error";
+};
+export type AuthClientRequest = { socket: PRGLIOSocket } | { httpReq: ExpressReq };
+
+type ThirdPartyProviders = {
+  facebook?: Pick<FacebookStrategy, "clientID" | "clientSecret"> & {
+    // appId: string;
+    // appSecret: string;
+    authOpts: AuthenticateOptions;
+  };
+  google?: Pick<GoogleStrategy, "clientID" | "clientSecret"> & {
+    authOpts: AuthenticateOptions;
+  };
+  github?: Pick<GitHubStrategy, "clientID" | "clientSecret"> & {
+    authOpts: AuthenticateOptions;
+  };
+  microsoft?: Pick<MicrosoftStrategyOptions, "clientID" | "clientSecret"> & {
+    authOpts: AuthenticateOptions;
+  };
+};
+
+type SMTPConfig = {
+  type: "aws-ses" | "smtp";
+  host: string;
+  port: number;
+  secure: boolean;
+  auth: {
+    user: string;
+    pass: string;
+  }
+}
+
+type RegistrationProviders = ThirdPartyProviders & {
+  email: {
+    signupType: "withMagicLink" | "withPassword";
+    smtp: SMTPConfig
+  } | {
+    signupType: "withPassword";
+    /**
+     * If provided, the user will be required to confirm their email address
+     */
+    smtp?: SMTPConfig;
+  };
+}
+
+type RegistrationData = 
+| {
+  provider: "email";
+  profile: {
+    username: string;
+    password: string;
+  }
+} 
+| {
+  provider: "google";
+  profile: GoogleProfile;
+  accessToken: string; 
+  refreshToken: string;
+}
+| {
+  provider: "github";
+  profile: GitHubProfile;
+  accessToken: string; 
+  refreshToken: string;
+}
+| {
+  provider: "facebook";
+  profile: FacebookProfile;
+  accessToken: string; 
+  refreshToken: string;
+}
+| {
+  provider: "microsoft";
+  profile: any;
+  accessToken: string; 
+  refreshToken: string;
+}
+
+export type AuthRegistrationConfig = RegistrationProviders & {
+  /**
+   * Required for social login callback
+   */
+  websiteUrl: string;
+
+  /**
+   * Do something with the registered user
+   */
+  onRegister: (data: RegistrationData) => Promise<any>;
+};
+
+export type SessionUser<ServerUser extends UserLike = UserLike, ClientUser extends UserLike = UserLike> = {
+  /** 
+   * This user will be available in all serverside prostgles options
+   * id and type values will be available in the prostgles.user session variable in postgres
+   * */
+  user: ServerUser;
+  /**
+   * Controls which fields from user are available in postgres session variable
+   */
+  sessionFields?: FieldFilter<ServerUser>;
+  /**
+   * User data sent to the authenticated client
+   */
+  clientUser: ClientUser;
+}
+
+export type AuthResult<SU = SessionUser> = SU & { sid: string; } | {
+  user?: undefined; 
+  clientUser?: undefined; 
+  sid?: string;
+} | undefined;
+
+export type AuthRequestParams<S, SUser extends SessionUser> = { db: DB, dbo: DBOFullyTyped<S>; getUser: () => Promise<AuthResult<SUser>> }
+
+export type Auth<S = void, SUser extends SessionUser = SessionUser> = {
+  /**
+   * Name of the cookie or socket hadnshake query param that represents the session id. 
+   * Defaults to "session_id"
+   */
+  sidKeyName?: string;
+
+  /**
+   * Response time rounding in milliseconds to prevent timing attacks on login. Login response time should always be a multiple of this value. Defaults to 500 milliseconds
+   */
+  responseThrottle?: number;
+
+  expressConfig?: {
+    /**
+     * Express app instance. If provided Prostgles will attempt to set sidKeyName to user cookie
+     */
+    app: Express;
+
+    /**
+     * Used in allowing logging in through express. Defaults to /login
+     */
+    loginRoute?: string;
+
+    /**
+     * Used in allowing logging out through express. Defaults to /logout
+     */
+    logoutGetPath?: string;
+
+    /**
+     * Options used in setting the cookie after a successful login
+     */
+    cookieOptions?: AnyObject;
+
+    /**
+     * False by default. If false and userRoutes are provided then the socket will request window.location.reload if the current url is on a user route.
+     */
+    disableSocketAuthGuard?: boolean;
+
+    /**
+     * If provided, any client requests to NOT these routes (or their subroutes) will be redirected to loginRoute (if logged in) and then redirected back to the initial route after logging in
+     * If logged in the user is allowed to access these routes
+     */
+    publicRoutes?: string[];
+
+    /**
+     * Will attach a app.use listener and will expose getUser
+     * Used for blocking access
+     */
+    use?: (args: { req: ExpressReq; res: ExpressRes, next: NextFunction } & AuthRequestParams<S, SUser>) => void | Promise<void>;
+
+    /**
+     * Will be called after a GET request is authorised
+     * This means that 
+     */
+    onGetRequestOK?: (
+      req: ExpressReq, 
+      res: ExpressRes, 
+      params: AuthRequestParams<S, SUser>
+    ) => any;
+
+    /**
+     * Name of get url parameter used in redirecting user after successful login. 
+     * Defaults to "returnURL"
+     */
+    returnUrlParamName?: string;
+
+    /**
+     * If defined, will check the magic link id and log in the user and redirect to the returnUrl if set
+     */
+    magicLinks?: {
+
+      /**
+       * Will default to /magic-link
+       */
+      route?: string;
+
+      /**
+       * Used in creating a session/logging in using a magic link
+       */
+      check: (magicId: string, dbo: DBOFullyTyped<S>, db: DB, client: LoginClientInfo) => Awaitable<BasicSession | undefined>;
+    }
+
+    registrations?: AuthRegistrationConfig;
+  }
+
+  /**
+   * undefined sid is allowed to enable public users
+   */
+  getUser: (sid: string | undefined, dbo: DBOFullyTyped<S>, db: DB, client: AuthClientRequest & LoginClientInfo) => Awaitable<AuthResult<SUser>>;
+
+  register?: (params: AnyObject, dbo: DBOFullyTyped<S>, db: DB) => Awaitable<BasicSession> | BasicSession;
+  login?: (params: AnyObject, dbo: DBOFullyTyped<S>, db: DB, client: LoginClientInfo) => Awaitable<BasicSession> | BasicSession;
+  logout?: (sid: string | undefined, dbo: DBOFullyTyped<S>, db: DB) => Awaitable<any>;
+
+  /**
+   * If provided then session info will be saved on socket.__prglCache and reused from there
+   */
+  cacheSession?: {
+    getSession: (sid: string | undefined, dbo: DBOFullyTyped<S>, db: DB) => Awaitable<BasicSession>
+  }
+}

package/lib/Auth/authInit.ts

@@ -0,0 +1,166 @@
+import { DBOFullyTyped } from "../DBSchemaBuilder";
+import { AuthHandler, getLoginClientInfo, HTTPCODES } from "./AuthHandler";
+import { AuthClientRequest, ExpressReq, ExpressRes } from "./AuthTypes";
+import { setAuthSignup } from "./setAuthSignup";
+
+export async function authInit(this: AuthHandler) {
+  if (!this.opts) return;
+
+  this.opts.sidKeyName = this.opts.sidKeyName || "session_id";
+  const { sidKeyName, login, getUser, expressConfig } = this.opts;
+  this.sidKeyName = this.opts.sidKeyName;
+
+  if (typeof sidKeyName !== "string" && !login) {
+    throw "Invalid auth: Provide { sidKeyName: string } ";
+  }
+  /**
+   * Why ??? Collision with socket.io ???
+   */
+  if (this.sidKeyName === "sid") throw "sidKeyName cannot be 'sid' please provide another name.";
+
+  if (!getUser) throw "getUser missing from auth config";
+
+  if (expressConfig) {
+    const { app, publicRoutes = [], onGetRequestOK, magicLinks, use } = expressConfig;
+    if (publicRoutes.find(r => typeof r !== "string" || !r)) {
+      throw "Invalid or empty string provided within publicRoutes "
+    }
+
+    setAuthSignup(expressConfig);
+
+    if(use){
+      app.use((req, res, next) => {
+        use({ 
+          req, 
+          res, 
+          next, 
+          getUser: () => this.getUser({ httpReq: req }) as any,
+          dbo: this.dbo as DBOFullyTyped, 
+          db: this.db,
+        })
+      })
+    }
+
+    if (magicLinks && this.routes.magicLinks) {
+      const { check } = magicLinks;
+      if (!check) throw "Check must be defined for magicLinks";
+
+      app.get(this.routes.magicLinks?.expressRoute, 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 });
+          }
+        }
+      });
+    }
+
+    const loginRoute = this.routes?.login;
+    if (loginRoute) {
+      app.post(loginRoute, async (req: ExpressReq, res: ExpressRes) => {
+        try {
+          const start = Date.now();
+          const { sid, expires } = await this.loginThrottled(req.body || {}, getLoginClientInfo({ httpReq: req })) || {};
+          await this.prostgles.opts.onLog?.({
+            type: "auth",
+            command: "login",
+            duration: Date.now() - start,
+            sid,
+            socketId: undefined,
+          })
+          if (sid) {
+
+            this.setCookieAndGoToReturnURLIFSet({ sid, expires }, { req, res });
+
+          } else {
+            throw ("Internal error: no user or session")
+          }
+        } catch (err) {
+          console.log(err)
+          res.status(HTTPCODES.AUTH_ERROR).json({ err });
+        }
+
+      });
+
+      if (this.routes.logoutGetPath && this.opts.logout) {
+        app.get(this.routes.logoutGetPath, async (req: ExpressReq, res: ExpressRes) => {
+          const sid = this.validateSid(req?.cookies?.[sidKeyName]);
+          if (sid) {
+            try {
+              await this.throttledFunc(() => {
+                return this.opts!.logout!(req?.cookies?.[sidKeyName], this.dbo as any, this.db);
+              })
+            } catch (err) {
+              console.error(err);
+            }
+          }
+          res.redirect("/")
+        });
+      }
+
+      if (Array.isArray(publicRoutes)) {
+
+        /* Redirect if not logged in and requesting non public content */
+        app.get(this.routes.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);
+
+            /**
+             * 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(`${loginRoute}?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(loginRoute, 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/Auth/getSafeReturnURL.ts

@@ -0,0 +1,35 @@
+export const getSafeReturnURL = (returnURL: string, returnUrlParamName: string, quiet = false) => {
+  /** Dissalow redirect to other domains */
+  if(returnURL) {
+    const allowedOrigin = "https://localhost";
+    const { origin, pathname, search, searchParams } = new URL(returnURL, allowedOrigin);
+    if(
+      origin !== allowedOrigin ||
+      returnURL !== `${pathname}${search}` ||
+      searchParams.get(returnUrlParamName)
+    ){
+      if(!quiet){
+        console.error(`Unsafe returnUrl: ${returnURL}. Redirecting to /`);
+      }
+      return "/";
+    }
+
+    return returnURL;
+  }
+}
+
+const issue = ([
+  ["https://localhost", "/"],
+  ["//localhost.bad.com", "/"],
+  ["//localhost.com", "/"],
+  ["/localhost/com", "/localhost/com"],
+  ["/localhost/com?here=there", "/localhost/com?here=there"],
+  ["/localhost/com?returnUrl=there", "/"],
+  ["//http://localhost.com", "/"],
+  ["//abc.com", "/"],
+  ["///abc.com", "/"],
+] as const).find(([returnURL, expected]) => getSafeReturnURL(returnURL, "returnUrl", true) !== expected);
+
+if(issue){
+  throw new Error(`getSafeReturnURL failed for ${issue[0]}. Expected: ${issue[1]}`);
+}

package/lib/Auth/setAuthSignup.ts

@@ -0,0 +1,100 @@
+import { Auth } from './AuthTypes';
+import passport from "passport";
+import { Strategy as GoogleStrategy } from "passport-google-oauth20";
+import { Strategy as GitHubStrategy } from "passport-github2";
+import { Strategy as MicrosoftStrategy } from "passport-microsoft";
+import { Strategy as FacebookStrategy } from "passport-facebook";
+import { AuthSocketSchema, getKeys, isDefined, isEmpty } from "prostgles-types";
+
+export const setAuthSignup = ({ registrations, app }: Required<Auth>["expressConfig"]) => {
+  if(!registrations) return;
+  const { email, onRegister, websiteUrl, ...providers } = registrations;
+  if(email){
+    app.post("/signup", async (req, res) => {
+      const { username, password } = req.body;
+      if(typeof username !== "string" || typeof password !== "string"){
+        res.status(400).json({ msg: "Invalid username or password" });
+        return;
+      }
+      await onRegister({ provider: "email", profile: { username, password }});
+    })
+  }
+
+  if(!isEmpty(providers)){
+    app.use(passport.initialize());
+  }
+
+  ([
+    providers.google && {
+      providerName: "google"  as const,
+      config: providers.google,
+      strategy: GoogleStrategy,
+    }, 
+    providers.github && {
+      providerName: "github"  as const,
+      config: providers.github,
+      strategy: GitHubStrategy,
+    },
+    providers.facebook && {
+      providerName: "facebook"  as const,
+      config: providers.facebook,
+      strategy: FacebookStrategy,
+    },
+    providers.microsoft && {
+      providerName: "microsoft"  as const,
+      config: providers.microsoft,
+      strategy: MicrosoftStrategy,
+    }
+  ])
+  .filter(isDefined)
+  .forEach(({
+    config: { authOpts, ...config },
+    strategy,
+    providerName,
+  }) => {
+
+    const callbackPath = `/auth/${providerName}/callback`;
+    passport.use(
+      new (strategy as typeof GoogleStrategy)(
+        {
+          ...config as any,
+          callbackURL: `${websiteUrl}${callbackPath}`,
+        },
+        async (accessToken, refreshToken, profile, done) => {
+          // This callback is where you would normally store or retrieve user info from the database
+          await onRegister({ provider: providerName as "google", accessToken, refreshToken, profile });
+          return done(null, profile);
+        }
+      )
+    );
+
+    app.get(`/auth/${providerName}`,
+      passport.authenticate(providerName, authOpts)
+    );
+
+    app.get(callbackPath,
+      passport.authenticate(providerName, { failureRedirect: '/' }),
+      (req, res) => {
+        // Successful authentication, redirect to main page
+        res.redirect('/');
+      }
+    );
+  });
+}
+
+export const getProviders = (registrations: Required<Auth>["expressConfig"]["registrations"]): AuthSocketSchema["providers"] | undefined => {
+  if(!registrations) return undefined;
+  const { email, websiteUrl, onRegister, ...providers } = registrations;
+  if(isEmpty(providers)) return undefined;
+ 
+  const result: AuthSocketSchema["providers"] = {}
+  getKeys(providers).forEach(providerName => {
+    if(providers[providerName]?.clientID){
+      result[providerName] = {
+        url: `/auth/${providerName}`,
+      }
+    }
+  });
+
+  return result;
+}

package/lib/DBSchemaBuilder.ts

@@ -1,6 +1,6 @@
 import { AnyObject, DbJoinMaker, DBSchema, isObject, JSONB, SQLHandler, TableHandler, ViewHandler } from "prostgles-types";
 import prostgles from ".";
-import { Auth } from "./AuthHandler";
+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";

package/lib/DboBuilder/DboBuilderTypes.ts

@@ -12,9 +12,10 @@ import {
   EXISTS_KEY,
   RawJoinPath,
   SQLHandler,
-  TableInfo as TInfo
+  TableInfo as TInfo,
+  UserLike
 } from "prostgles-types";
-import { BasicSession, ExpressReq, UserLike } from "../AuthHandler";
+import { BasicSession, ExpressReq } from "../Auth/AuthTypes";
 import { BasicCallback } from "../PubSubManager/PubSubManager";
 import {
   PublishAllOrNothing
@@ -182,7 +183,7 @@ export type PRGLIOSocket = {
   __prglCache?: {
     session: BasicSession;
     user: UserLike;
-    clientUser: AnyObject;
+    clientUser: UserLike;
   }
 
   _user?: AnyObject

package/lib/FileManager/initFileManager.ts

@@ -5,7 +5,7 @@ import { canCreateTables } from "../DboBuilder/runSQL";
 import { Prostgles } from "../Prostgles";
 import { FileManager, HOUR, LocalConfig } from "./FileManager";
 import { runClientRequest } from "../runClientRequest";
-import { HTTPCODES } from "../AuthHandler";
+import { HTTPCODES } from "../Auth/AuthHandler";
 
 export async function initFileManager(this: FileManager, prg: Prostgles){
   this.prostgles = prg;

package/lib/Prostgles.ts

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 import * as pgPromise from 'pg-promise';
-import { AuthHandler } from "./AuthHandler";
+import { AuthHandler } from "./Auth/AuthHandler";
 import { FileManager } from "./FileManager/FileManager";
 import { SchemaWatch } from "./SchemaWatch/SchemaWatch";
 import { OnInitReason, initProstgles } from "./initProstgles";
@@ -495,7 +495,7 @@ export class Prostgles {
         return aName.localeCompare(bName);        
       });
 
-      const { auth } = clientReq.socket? await this.authHandler.makeSocketAuth(clientReq.socket) : { auth: {} };
+      const { auth } = await this.authHandler.getClientAuth(clientReq);
       
       const clientSchema: ClientSchema = {
         schema,

package/lib/ProstglesTypes.ts

@@ -1,6 +1,6 @@
 
 import { FileColumnConfig } from "prostgles-types";
-import { Auth, AuthRequestParams, SessionUser } from "./AuthHandler";
+import { Auth, AuthRequestParams, SessionUser } from "./Auth/AuthTypes";
 import { EventTriggerTagFilter } from "./Event_Trigger_Tags";
 import { CloudClient, ImageOptions, LocalConfig } from "./FileManager/FileManager";
 import { EventInfo } from "./Logging";

package/lib/PubSubManager/PubSubManager.ts

@@ -296,9 +296,10 @@ export class PubSubManager {
     }
   }
 
-  getClientSubs(client: Pick<Subscription, "localFuncs" | "socket_id" | "channel_name">): Subscription[] { 
+  getClientSubs({ channel_name, localFuncs, socket_id }: Pick<Subscription, "localFuncs" | "socket_id" | "channel_name">): Subscription[] { 
     return this.subs.filter(s => {
-      return s.channel_name === client.channel_name && (matchesLocalFuncs(client.localFuncs, s.localFuncs) || client.socket_id && s.socket_id === client.socket_id)
+      return s.channel_name === channel_name && 
+        (matchesLocalFuncs(localFuncs, s.localFuncs) || socket_id && s.socket_id === socket_id)
     });
   }
 
@@ -334,7 +335,7 @@ export class PubSubManager {
     const { name: table_name } = table_info;
     
     if (!this.dbo?.[table_name]?.find) {
-      throw new Error(`1107 this.dbo.${table_name}.find`);
+      throw new Error(`this.dbo.${table_name}.find undefined`);
     }
 
     try {

package/lib/PublishParser/PublishParser.ts

@@ -1,12 +1,12 @@
-import { Method, getKeys, isObject } from "prostgles-types";
-import { AuthResult, SessionUser } from "../AuthHandler";
+import { Method, isObject } from "prostgles-types";
+import { AuthResult, SessionUser } from "../Auth/AuthTypes";
 import { LocalParams } from "../DboBuilder/DboBuilder";
 import { DB, DBHandlerServer, Prostgles } from "../Prostgles";
+import { VoidFunction } from "../SchemaWatch/SchemaWatch";
 import { getFileTableRules } from "./getFileTableRules";
 import { getSchemaFromPublish } from "./getSchemaFromPublish";
 import { getTableRulesWithoutFileTable } from "./getTableRulesWithoutFileTable";
 import { DboTable, DboTableCommand, ParsedPublishTable, PublishMethods, PublishObject, PublishParams, RULE_TO_METHODS, TableRule } from "./publishTypesAndUtils";
-import { VoidFunction } from "../SchemaWatch/SchemaWatch";
 
 export class PublishParser {
   publish: any;

package/lib/PublishParser/getFileTableRules.ts

@@ -1,5 +1,5 @@
 import { AnyObject, FullFilter, isDefined } from "prostgles-types";
-import { AuthResult } from "../AuthHandler";
+import { AuthResult } from "../Auth/AuthTypes";
 import { LocalParams } from "../DboBuilder/DboBuilder";
 import { parseFieldFilter } from "../DboBuilder/ViewHandler/parseFieldFilter";
 import { PublishParser } from "./PublishParser";

package/lib/PublishParser/getSchemaFromPublish.ts

@@ -1,5 +1,5 @@
 import { DBSchemaTable, MethodKey, TableInfo, TableSchemaForClient, getKeys, pickKeys } from "prostgles-types";
-import { AuthResult, ExpressReq } from "../AuthHandler";
+import { AuthResult, ExpressReq } from "../Auth/AuthTypes";
 import { getErrorAsObject, PRGLIOSocket } from "../DboBuilder/DboBuilder";
 import { PublishObject, PublishParser } from "./PublishParser"
 import { TABLE_METHODS } from "../Prostgles";

package/lib/PublishParser/getTableRulesWithoutFileTable.ts

@@ -1,5 +1,5 @@
 import { getKeys, isObject } from "prostgles-types";
-import { AuthResult } from "../AuthHandler";
+import { AuthResult } from "../Auth/AuthTypes";
 import { TableHandler } from "../DboBuilder/TableHandler/TableHandler";
 import { ViewHandler } from "../DboBuilder/ViewHandler/ViewHandler";
 import { DEFAULT_SYNC_BATCH_SIZE } from "../PubSubManager/PubSubManager";