@niledatabase/server 3.0.0-alpha.2 → 3.0.0-alpha.21

package/dist/tenants/index.d.ts

@@ -1,5 +1,5 @@
 import { Config } from '../utils/Config';
-import { NileRequest, NileResponse } from '../utils/Requester';
+import { NileRequest } from '../utils/Requester';
 export interface Tenant {
     id: string;
     name?: string;
@@ -12,6 +12,10 @@ export default class Tenants extends Config {
     get tenantUrl(): string;
     createTenant: (req: NileRequest<{
         name: string;
-    }>, init?: RequestInit) => NileResponse<Tenant>;
-    getTenant: (req: NileRequest<void>, init?: RequestInit) => NileResponse<Tenant>;
+    }> | Headers | string, init?: RequestInit) => Promise<Tenant | Response>;
+    getTenant: (req: NileRequest<{
+        id: string;
+    }> | Headers | string | void, init?: RequestInit) => Promise<Tenant | Response>;
+    get tenantListUrl(): string;
+    listTenants: (req: NileRequest<void> | Headers, init?: RequestInit) => Promise<Tenant[] | Response>;
 }

package/dist/types.d.ts

@@ -6,6 +6,12 @@ export type Opts = {
 export type NilePoolConfig = PoolConfig & {
     afterCreate?: AfterCreate;
 };
+export type LoggerType = {
+    info?: (args: unknown[]) => void;
+    warn?: (args: unknown[]) => void;
+    error?: (args: unknown[]) => void;
+    debug?: (args: unknown[]) => void;
+};
 export type ServerConfig = {
     databaseId?: string;
     user?: string;
@@ -14,6 +20,7 @@ export type ServerConfig = {
     tenantId?: string | null | undefined;
     userId?: string | null | undefined;
     debug?: boolean;
+    configureUrl?: string;
     db?: NilePoolConfig;
     api?: {
         version?: number;
@@ -21,6 +28,7 @@ export type ServerConfig = {
         cookieKey?: string;
         token?: string;
     };
+    logger?: LoggerType;
 };
 export type NileDb = NilePoolConfig & {
     tenantId?: string;

package/dist/users/index.d.ts

@@ -1,5 +1,5 @@
 import { Config } from '../utils/Config';
-import { NileRequest, NileResponse } from '../utils/Requester';
+import { NileRequest } from '../utils/Requester';
 export interface CreateBasicUserRequest {
     email: string;
     password: string;
@@ -34,19 +34,19 @@ export default class Users extends Config {
     get usersUrl(): string;
     get tenantUsersUrl(): string;
     handleHeaders(init?: RequestInit): RequestInit | undefined;
-    createUser: (req: NileRequest<CreateBasicUserRequest>, init?: RequestInit) => NileResponse<LoginUserResponse>;
-    updateUser: (userId: string, req: NileRequest<User>, init?: RequestInit) => NileResponse<User>;
-    listUsers: (req: NileRequest<void> | Headers, init?: RequestInit) => NileResponse<User[]>;
+    createUser: (req: NileRequest<CreateBasicUserRequest>, init?: RequestInit) => Promise<User | Response>;
+    updateUser: (userId: string, req: NileRequest<User>, init?: RequestInit) => Promise<User | Response>;
+    listUsers: (req: NileRequest<void> | Headers, init?: RequestInit) => Promise<User[] | Response>;
     linkUser: (req: NileRequest<{
         id: string;
-    }> | Headers, init?: RequestInit) => NileResponse<User[]>;
+    }> | Headers, init?: RequestInit) => Promise<User | Response>;
     tenantUsersDeleteUrl: (userId?: string) => string;
     getUserId: (req: Headers | NileRequest<{
         id: string;
     }>) => Promise<any>;
     unlinkUser: (req: NileRequest<{
         id: string;
-    }> | Headers, init?: RequestInit) => NileResponse<User[]>;
+    }> | Headers, init?: RequestInit) => Promise<User[] | Response>;
     get meUrl(): string;
-    me: (req: NileRequest<void>, init?: RequestInit) => NileResponse<User>;
+    me: (req: NileRequest<void> | Headers, init?: RequestInit) => Promise<User | Response>;
 }

package/dist/utils/Config/envVars.d.ts

@@ -11,12 +11,11 @@ export declare const getInfoBearer: (cfg: EnvConfig) => string;
 export declare const getToken: (cfg: EnvConfig) => string | undefined;
 export declare const getDatabaseName: (cfg: EnvConfig) => string | null;
 export declare const getTenantId: (cfg: EnvConfig) => string | null;
-export declare const getLocal: (cfg: EnvConfig) => string;
 /**
  * @param cfg various overrides
  * @returns the url for REST to use
  */
-export declare const getBasePath: (cfg: EnvConfig) => string;
+export declare const getBasePath: (cfg: EnvConfig) => undefined | string;
 export declare const getControlPlane: (cfg: EnvConfig) => string;
 export declare function getDbHost(cfg: EnvConfig): string;
 export declare function getDbPort(cfg: EnvConfig): number;

package/dist/utils/Config/index.d.ts

@@ -1,4 +1,4 @@
-import { NilePoolConfig, ServerConfig } from '../../types';
+import { LoggerType, NilePoolConfig, ServerConfig } from '../../types';
 export type ConfigRoutes = {
     SIGNIN?: string;
     SESSION?: string;
@@ -8,19 +8,18 @@ export type ConfigRoutes = {
     SIGNOUT?: string;
     ME?: string;
     ERROR?: string;
+    TENANTS?: string;
+    TENANT_USERS?: string;
+    USERS?: string;
 };
 declare class ApiConfig {
     cookieKey?: string;
-    basePath?: string;
-    version?: number;
-    localPath?: string;
+    basePath?: string | undefined;
     private _token?;
-    constructor({ basePath, cookieKey, token, version, localPath, }: {
-        basePath: string;
+    constructor({ basePath, cookieKey, token, }: {
+        basePath?: string | undefined;
         cookieKey: string;
         token: string | undefined;
-        version: number;
-        localPath: string;
     });
     get token(): string | undefined;
     set token(value: string | undefined);
@@ -32,6 +31,7 @@ export declare class Config {
     databaseName: string;
     routePrefix?: string;
     routes?: ConfigRoutes;
+    logger?: LoggerType;
     debug: boolean;
     db: NilePoolConfig;
     api: ApiConfig;

package/dist/utils/Event/index.d.ts

@@ -7,6 +7,5 @@ export declare const watchUserId: (cb: EventFn) => void;
 export declare const updateToken: (val: BusValues) => void;
 export declare const watchToken: (cb: EventFn) => void;
 export declare const watchEvictPool: (cb: EventFn) => void;
-export declare const closeEvictPool: (cb: EventFn) => void;
 export declare const evictPool: (val: BusValues) => void;
 export {};

package/dist/utils/Logger.d.ts

@@ -1,7 +1,8 @@
 import { ServerConfig } from '../types';
 import { Config } from './Config';
-export default function Logger(config: void | Config | ServerConfig, ...params: unknown[]): {
-    info(...args: unknown[]): void;
-    warn(...args: unknown[]): void;
-    error(...args: unknown[]): void;
+export default function Logger(config?: Config | ServerConfig, ...params: unknown[]): {
+    info: (message: string | unknown, meta?: Record<string, unknown>) => void;
+    warn: (message: string | unknown, meta?: Record<string, unknown>) => void;
+    error: (message: string | unknown, meta?: Record<string, unknown>) => void;
+    debug: (message: string | unknown, meta?: Record<string, unknown>) => void;
 };

package/dist/utils/Requester/index.d.ts

@@ -5,7 +5,7 @@ export default class Requester<T> extends Config {
     constructor(config: Config);
     rawRequest(method: Methods, url: string, init: RequestInit, body?: string): Promise<Response>;
     /**
-     * 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
@@ -16,8 +16,8 @@ export default class Requester<T> extends Config {
      * @returns
      */
     protected request(method: Methods, url: string, req: T | Headers, init?: RequestInit): Promise<Response>;
-    post: (req: T | Headers, url: string, init?: RequestInit) => Promise<Response>;
-    get: (req: T | Headers, url: string, init?: RequestInit) => Promise<Response>;
-    put: (req: T | Headers, url: string, init?: RequestInit) => Promise<Response>;
-    delete: (req: T | Headers, url: string, init?: RequestInit) => Promise<Response>;
+    post<R = JSON>(req: T | Headers, url: string, init?: RequestInit): Promise<Response | R>;
+    get<R = JSON>(req: T | Headers, url: string, init?: RequestInit): Promise<Response | R>;
+    put<R = JSON>(req: T | Headers, url: string, init?: RequestInit): Promise<Response | R>;
+    delete<R = JSON>(req: T | Headers, url: string, init?: RequestInit): Promise<Response | R>;
 }

package/dist/utils/Requester/types.d.ts

@@ -84,5 +84,5 @@ export interface APIError {
      */
     statusCode: number;
 }
-export type NileResponse<T> = Promise<NResponse<T & APIError>>;
+export type NileResponse<T> = Promise<T | NResponse<T & APIError>>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@niledatabase/server",
-  "version": "3.0.0-alpha.2",
+  "version": "3.0.0-alpha.21",
   "license": "MIT",
   "main": "./dist/index.js",
   "module": "./dist/server.esm.js",
@@ -74,5 +74,5 @@
     "jose": "^4.15.4",
     "pg": "^8.11.3"
   },
-  "gitHead": "7efb0236cc07c8021673e24f0fdb3e794b5f1775"
+  "gitHead": "e7fed252032085c4f2e81769374c0688284ad5fe"
 }

package/dist/utils/Server/index.d.ts

@@ -1,4 +0,0 @@
-import { ServerConfig } from '../../types';
-import { Config } from '../Config';
-export declare const getServerId: (config: ServerConfig) => string;
-export declare const makeServerId: (config: Config) => string;