fix(server): fixes for v3

packages/server/src/Api.ts

@@ -0,0 +1,38 @@
+import Handlers from './api/handlers';
+import { Routes } from './api/types';
+import { appRoutes } from './api/utils/routes/defaultRoutes';
+import serverAuth from './auth';
+import Tenants from './tenants';
+import Users from './users';
+import { Config } from './utils/Config';
+
+export class Api {
+  config: Config;
+  users: Users;
+  tenants: Tenants;
+  routes: Routes;
+  handlers: {
+    GET: (req: Request) => Promise<void | Response>;
+    POST: (req: Request) => Promise<void | Response>;
+    DELETE: (req: Request) => Promise<void | Response>;
+    PUT: (req: Request) => Promise<void | Response>;
+  };
+  constructor(config: Config) {
+    this.config = config;
+    this.users = new Users(config);
+    this.tenants = new Tenants(config);
+    this.routes = {
+      ...appRoutes(config?.routePrefix),
+      ...config?.routes,
+    };
+    this.handlers = Handlers(this.routes, config);
+  }
+
+  set headers(headers: Headers) {
+    this.users = new Users(this.config, headers);
+    this.tenants = new Tenants(this.config, headers);
+  }
+  async login(payload: { email: string; password: string }) {
+    this.headers = await serverAuth(this.config, this.handlers)(payload);
+  }
+}

packages/server/src/Server.ts

@@ -2,46 +2,10 @@ import { Pool } from 'pg';
 
 import { ServerConfig } from './types';
 import { Config } from './utils/Config';
-import Users from './users';
-import Tenants from './tenants';
 import { watchTenantId, watchToken, watchUserId } from './utils/Event';
 import DbManager from './db';
 import { getServerId, makeServerId } from './utils/Server';
-import serverAuth from './auth';
-import { appRoutes } from './api/utils/routes/defaultRoutes';
-import Handlers from './api/handlers';
-import { Routes } from './api/types';
-
-class Api {
-  config: Config;
-  users: Users;
-  tenants: Tenants;
-  routes: Routes;
-  handlers: {
-    GET: (req: Request) => Promise<void | Response>;
-    POST: (req: Request) => Promise<void | Response>;
-    DELETE: (req: Request) => Promise<void | Response>;
-    PUT: (req: Request) => Promise<void | Response>;
-  };
-  constructor(config: Config) {
-    this.config = config;
-    this.users = new Users(config);
-    this.tenants = new Tenants(config);
-    this.routes = {
-      ...appRoutes(config?.routePrefix),
-      ...config?.routes,
-    };
-    this.handlers = Handlers(this.routes, config);
-  }
-
-  set headers(headers: Headers) {
-    this.users = new Users(this.config, headers);
-    this.tenants = new Tenants(this.config, headers);
-  }
-  async login(payload: { email: string; password: string }) {
-    this.headers = await serverAuth(this.config, this.handlers)(payload);
-  }
-}
+import { Api } from './Api';
 
 export class Server {
   config: Config;
@@ -136,7 +100,6 @@ export class Server {
     }
   }
   get db(): Pool {
-    // only need to interact with the knex object
     return this.manager.getConnection(this.config);
   }
 
@@ -167,8 +130,11 @@ export class Server {
       return existing;
     }
 
-    this.servers.set(serverId, new Server(_config));
-    return this.servers.get(serverId) as unknown as Server;
+    const newServer = new Server(_config);
+
+    this.servers.set(serverId, newServer);
+
+    return newServer;
   }
 }
 

packages/server/src/db/DBManager.ts

@@ -6,6 +6,7 @@ import Logger from '../utils/Logger';
 import { ServerConfig } from '../types';
 
 import NileDatabase from './NileInstance';
+import { isUUID } from './isUUID';
 
 export default class DBManager {
   connections: Map<string, NileDatabase>;
@@ -15,10 +16,10 @@ export default class DBManager {
     tenantId?: string | undefined | null,
     userId?: string | undefined | null
   ) {
-    if (tenantId && userId) {
+    if (isUUID(tenantId) && isUUID(userId)) {
       return `${tenantId}:${userId}`;
     }
-    if (tenantId) {
+    if (isUUID(tenantId)) {
       return `${tenantId}`;
     }
     return 'base';

packages/server/src/db/NileInstance.ts

@@ -7,6 +7,7 @@ import { AfterCreate } from '../types';
 import Logger from '../utils/Logger';
 
 import { createProxyForPool } from './PoolProxy';
+import { isUUID } from './isUUID';
 
 class NileDatabase {
   pool: Pool;
@@ -95,9 +96,9 @@ function makeAfterCreate(config: Config): AfterCreate {
       done(error, conn);
     });
 
-    if (config.tenantId) {
+    if (isUUID(config.tenantId)) {
       const query = [`SET nile.tenant_id = '${config.tenantId}'`];
-      if (config.userId) {
+      if (isUUID(config.userId)) {
         if (!config.tenantId) {
           warn('A user id cannot be set in context without a tenant id');
         }
@@ -106,10 +107,10 @@ function makeAfterCreate(config: Config): AfterCreate {
 
       // in this example we use pg driver's connection API
       conn.query(query.join(';'), function (err: Error) {
-        if (config.tenantId) {
+        if (query.length === 1) {
           info('[tenant id]', config.tenantId);
         }
-        if (config.userId) {
+        if (query.length === 2) {
           info('[user id]', config.userId);
         }
         done(err, conn);

packages/server/src/db/isUUID.ts

@@ -0,0 +1,8 @@
+export function isUUID(value: string | null | undefined) {
+  if (!value) {
+    return false;
+  }
+  const regex =
+    /^[0-9a-f]{8}-[0-9a-f]{4}-7[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+  return regex.test(value);
+}

packages/server/src/tenants/index.ts

@@ -1,5 +1,5 @@
 import { Config } from '../utils/Config';
-import Requester, { NileRequest, NileResponse } from '../utils/Requester';
+import Requester, { NileRequest } from '../utils/Requester';
 
 export interface Tenant {
   id: string;
@@ -34,30 +34,45 @@ export default class Tenants extends Config {
   }
 
   createTenant = async (
-    req: NileRequest<{ name: string }>,
+    req: NileRequest<{ name: string }> | Headers | string,
     init?: RequestInit
-  ): NileResponse<Tenant> => {
+  ): Promise<Tenant | Response> => {
+    let _req;
+    if (typeof req === 'string') {
+      _req = new Request(`${this.api.basePath}${this.tenantsUrl}`, {
+        body: JSON.stringify({ name: req }),
+        method: 'POST',
+      });
+    } else {
+      _req = req;
+    }
     const _requester = new Requester(this);
     const _init = this.handleHeaders(init);
-    return _requester.post(req, this.tenantsUrl, _init);
+    return _requester.post(_req, this.tenantsUrl, _init);
   };
 
   getTenant = async (
-    req: NileRequest<void>,
+    req: NileRequest<{ id: string }> | Headers | string | void,
     init?: RequestInit
-  ): NileResponse<Tenant> => {
+  ): Promise<Tenant | Response> => {
+    if (typeof req === 'string') {
+      this.tenantId = req;
+    }
     const _requester = new Requester(this);
     const _init = this.handleHeaders(init);
-    return _requester.get(req, this.tenantUrl, _init);
+    return _requester.get<Tenant>(req, this.tenantUrl, _init);
   };
 
   get tenantListUrl() {
     return `/users/${this.userId ?? '{userId}'}/tenants`;
   }
 
-  listTenants = async (req: NileRequest<void>, init?: RequestInit) => {
+  listTenants = async (
+    req: NileRequest<void> | Headers,
+    init?: RequestInit
+  ): Promise<Tenant[] | Response> => {
     const _requester = new Requester(this);
     const _init = this.handleHeaders(init);
-    return _requester.get(req, this.tenantListUrl, _init);
+    return _requester.get<Tenant[]>(req, this.tenantListUrl, _init);
   };
 }

packages/server/src/users/index.ts

@@ -1,5 +1,5 @@
 import { Config } from '../utils/Config';
-import Requester, { NileRequest, NileResponse } from '../utils/Requester';
+import Requester, { NileRequest } from '../utils/Requester';
 
 export interface CreateBasicUserRequest {
   email: string;
@@ -65,7 +65,7 @@ export default class Users extends Config {
   createUser = async (
     req: NileRequest<CreateBasicUserRequest>,
     init?: RequestInit
-  ): NileResponse<LoginUserResponse> => {
+  ): Promise<User | Response> => {
     const _requester = new Requester(this);
 
     const _init = this.handleHeaders(init);
@@ -76,7 +76,7 @@ export default class Users extends Config {
     userId: string,
     req: NileRequest<User>,
     init?: RequestInit
-  ): NileResponse<User> => {
+  ): Promise<User | Response> => {
     const _requester = new Requester(this);
     const _init = this.handleHeaders(init);
     return await _requester.put(req, `${this.usersUrl}/${userId}`, _init);
@@ -85,7 +85,7 @@ export default class Users extends Config {
   listUsers = async (
     req: NileRequest<void> | Headers,
     init?: RequestInit
-  ): NileResponse<User[]> => {
+  ): Promise<User[] | Response> => {
     const _requester = new Requester(this);
     const _init = this.handleHeaders(init);
     return await _requester.get(req, this.tenantUsersUrl, _init);
@@ -94,7 +94,7 @@ export default class Users extends Config {
   linkUser = async (
     req: NileRequest<{ id: string }> | Headers,
     init?: RequestInit
-  ): NileResponse<User[]> => {
+  ): Promise<User | Response> => {
     const _requester = new Requester(this);
     const _init = this.handleHeaders(init);
     return await _requester.put(req, this.tenantUsersUrl, _init);
@@ -122,7 +122,7 @@ export default class Users extends Config {
   unlinkUser = async (
     req: NileRequest<{ id: string }> | Headers,
     init?: RequestInit
-  ): NileResponse<User[]> => {
+  ): Promise<User[] | Response> => {
     const _requester = new Requester(this);
     const userId = await this.getUserId(req);
     const _init = this.handleHeaders(init);
@@ -138,9 +138,9 @@ export default class Users extends Config {
   }
 
   me = async (
-    req: NileRequest<void>,
+    req: NileRequest<void> | Headers,
     init?: RequestInit
-  ): NileResponse<User> => {
+  ): Promise<User | Response> => {
     const _requester = new Requester(this);
     const _init = this.handleHeaders(init);
     return await _requester.get(req, this.meUrl, _init);

packages/server/src/utils/Requester/index.ts

@@ -32,7 +32,7 @@ export default class Requester<T> extends Config {
   }
 
   /**
-   * three optios here
+   * three options here
    * 1) pass in headers for a server side request
    * 2) pass in the payload that matches the api
    * 3) pass in the request object sent by a browser
@@ -96,35 +96,51 @@ export default class Requester<T> extends Config {
     return await this.rawRequest(method, url, _init, body);
   }
 
-  post = async (
+  async post<R = JSON>(
     req: T | Headers,
     url: string,
     init?: RequestInit
-  ): Promise<Response> => {
-    return await this.request('POST', url, req, init);
-  };
+  ): Promise<Response | R> {
+    const response = await this.request('POST', url, req, init);
+    if (response && response.status >= 200 && response.status < 300) {
+      return response.json();
+    }
+    return response;
+  }
 
-  get = async (
+  async get<R = JSON>(
     req: T | Headers,
     url: string,
     init?: RequestInit
-  ): Promise<Response> => {
-    return await this.request('GET', url, req, init);
-  };
+  ): Promise<Response | R> {
+    const response = await this.request('GET', url, req, init);
+    if (response && response.status >= 200 && response.status < 300) {
+      return response.json();
+    }
+    return response;
+  }
 
-  put = async (
+  async put<R = JSON>(
     req: T | Headers,
     url: string,
     init?: RequestInit
-  ): Promise<Response> => {
-    return await this.request('PUT', url, req, init);
-  };
+  ): Promise<Response | R> {
+    const response = await this.request('PUT', url, req, init);
+    if (response && response.status >= 200 && response.status < 300) {
+      return response.json();
+    }
+    return response;
+  }
 
-  delete = async (
+  async delete<R = JSON>(
     req: T | Headers,
     url: string,
     init?: RequestInit
-  ): Promise<Response> => {
-    return await this.request('DELETE', url, req, init);
-  };
+  ): Promise<Response | R> {
+    const response = await this.request('DELETE', url, req, init);
+    if (response && response.status >= 200 && response.status < 300) {
+      return response.json();
+    }
+    return response;
+  }
 }

packages/server/src/utils/Requester/types.ts

@@ -94,4 +94,4 @@ export interface APIError {
   statusCode: number;
 }
 
-export type NileResponse<T> = Promise<NResponse<T & APIError>>;
+export type NileResponse<T> = Promise<T | NResponse<T & APIError>>;

packages/server/src/utils/Server/index.ts

@@ -6,5 +6,5 @@ export const getServerId = (config: ServerConfig) => {
   return makeServerId(cfg);
 };
 export const makeServerId = (config: Config) => {
-  return Buffer.from(JSON.stringify(config), 'base64').toString();
+  return Buffer.from(JSON.stringify(config), 'utf8').toString('base64');
 };