@niledatabase/server 3.0.0-alpha.4 → 3.0.0-alpha.40

package/dist/tenants/index.d.ts

@@ -1,9 +1,6 @@
 import { Config } from '../utils/Config';
-import { NileRequest, NileResponse } from '../utils/Requester';
-export interface Tenant {
-    id: string;
-    name?: string;
-}
+import { NileRequest } from '../utils/Requester';
+import { Tenant } from './types';
 export default class Tenants extends Config {
     headers?: Headers;
     constructor(config: Config, headers?: Headers);
@@ -12,8 +9,14 @@ 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>, init?: RequestInit) => Promise<Response>;
+    listTenants: (req: NileRequest<void> | Headers, init?: RequestInit) => Promise<Tenant[] | Response>;
+    deleteTenant: (req: NileRequest<void> | Headers | string, init?: RequestInit) => Promise<Response>;
+    updateTenant: (req: NileRequest<void> | Headers | {
+        name: string;
+    }, init?: RequestInit) => Promise<Tenant | Response>;
 }

package/dist/tenants/types.d.ts

@@ -0,0 +1,4 @@
+export interface Tenant {
+    id: string;
+    name?: string;
+}

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,8 @@ export type ServerConfig = {
     tenantId?: string | null | undefined;
     userId?: string | null | undefined;
     debug?: boolean;
+    configureUrl?: string;
+    secureCookies?: boolean;
     db?: NilePoolConfig;
     api?: {
         version?: number;
@@ -21,6 +29,7 @@ export type ServerConfig = {
         cookieKey?: string;
         token?: string;
     };
+    logger?: LoggerType;
 };
 export type NileDb = NilePoolConfig & {
     tenantId?: string;

package/dist/users/index.d.ts

@@ -1,52 +1,27 @@
 import { Config } from '../utils/Config';
-import { NileRequest, NileResponse } from '../utils/Requester';
-export interface CreateBasicUserRequest {
-    email: string;
-    password: string;
-    preferredName?: string;
-    newTenant?: string;
-}
-export declare const LoginUserResponseTokenTypeEnum: {
-    readonly AccessToken: "ACCESS_TOKEN";
-    readonly RefreshToken: "REFRESH_TOKEN";
-    readonly IdToken: "ID_TOKEN";
-};
-export type LoginUserResponseTokenTypeEnum = (typeof LoginUserResponseTokenTypeEnum)[keyof typeof LoginUserResponseTokenTypeEnum];
-export interface LoginUserResponseToken {
-    jwt: string;
-    maxAge: number;
-    type: LoginUserResponseTokenTypeEnum;
-}
-export interface LoginUserResponse {
-    [key: string]: any;
-    id: string;
-    token: LoginUserResponseToken;
-}
-export interface User {
-    id?: string;
-    tenants?: Set<string>;
-    email?: string;
-    preferredName?: string;
-}
+import { NileRequest } from '../utils/Requester';
+import { CreateBasicUserRequest, User } from './types';
 export default class Users extends Config {
     headers?: Headers;
     constructor(config: Config, headers?: Headers);
     get usersUrl(): string;
     get tenantUsersUrl(): string;
+    get linkUsersUrl(): string;
+    get tenantUserUrl(): 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>;
+    createTenantUser: (req: NileRequest<CreateBasicUserRequest>, init?: RequestInit) => Promise<User | Response>;
+    updateUser: (req: NileRequest<Partial<Omit<User, "email" | "tenants" | "created" | "updated">>>, 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[]>;
-    tenantUsersDeleteUrl: (userId?: string) => string;
-    getUserId: (req: Headers | NileRequest<{
-        id: string;
-    }>) => Promise<any>;
+        tenantId?: string;
+    }> | Headers | string, init?: RequestInit) => Promise<User | Response>;
     unlinkUser: (req: NileRequest<{
         id: string;
-    }> | Headers, init?: RequestInit) => NileResponse<User[]>;
+        tenantId?: string;
+    }> | Headers | string, init?: RequestInit) => Promise<Response>;
     get meUrl(): string;
-    me: (req: NileRequest<void>, init?: RequestInit) => NileResponse<User>;
+    me: (req: NileRequest<void> | Headers, init?: RequestInit) => Promise<User | Response>;
+    updateMe: (req: NileRequest<Partial<Omit<User, "email" | "id" | "tenants" | "created" | "updated">>> | Headers, init?: RequestInit) => Promise<User | Response>;
 }

package/dist/users/types.d.ts

@@ -0,0 +1,36 @@
+export interface CreateBasicUserRequest {
+    email: string;
+    password: string;
+    preferredName?: string;
+    newTenant?: string;
+}
+export declare const LoginUserResponseTokenTypeEnum: {
+    readonly AccessToken: "ACCESS_TOKEN";
+    readonly RefreshToken: "REFRESH_TOKEN";
+    readonly IdToken: "ID_TOKEN";
+};
+export type LoginUserResponseTokenTypeEnum = (typeof LoginUserResponseTokenTypeEnum)[keyof typeof LoginUserResponseTokenTypeEnum];
+export interface LoginUserResponseToken {
+    jwt: string;
+    maxAge: number;
+    type: LoginUserResponseTokenTypeEnum;
+}
+export interface LoginUserResponse {
+    [key: string]: any;
+    id: string;
+    token: LoginUserResponseToken;
+}
+export interface User {
+    id: string;
+    email: string;
+    name: string | null;
+    familyName: string | null;
+    givenName: string | null;
+    picture: string | null;
+    created: string;
+    updated: string;
+    emailVerified: boolean | null;
+    tenants: {
+        id: string;
+    }[];
+}

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

@@ -4,19 +4,19 @@ export type EnvConfig = {
     logger?: string;
     config?: ServerConfig;
 };
+export declare const getSecureCookies: (cfg: EnvConfig) => boolean | undefined;
 export declare const getDatabaseId: (cfg: EnvConfig) => string | undefined;
 export declare const getUsername: (cfg: EnvConfig) => string | undefined;
 export declare const getPassword: (cfg: EnvConfig) => string | undefined;
 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 getDatabaseName: (cfg: EnvConfig) => string | null | undefined;
 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 getControlPlane: (cfg: EnvConfig) => string;
-export declare function getDbHost(cfg: EnvConfig): string;
+export declare const getBasePath: (cfg: EnvConfig) => undefined | string;
+export declare const getControlPlane: (cfg: EnvConfig) => string | undefined;
+export declare function getDbHost(cfg: EnvConfig): string | undefined;
 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,8 @@ export declare class Config {
     databaseName: string;
     routePrefix?: string;
     routes?: ConfigRoutes;
+    logger?: LoggerType;
+    secureCookies?: boolean | undefined;
     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(req: T | Headers, url: string, init?: RequestInit): Promise<Response>;
 }

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/dist/utils/fetch.d.ts

@@ -3,7 +3,9 @@ import { Config } from './Config';
 import { NileRequest } from './Requester';
 export declare const X_NILE_TENANT = "niledb-tenant-id";
 export declare const X_NILE_USER_ID = "niledb-user-id";
+export declare const X_NILE_SECURECOOKIES = "niledb-useSecureCookies";
 export declare function handleTenantId(req: NileRequest<any>, config: Config): ResponseError | void;
 export declare function getTenantFromHttp(headers: Headers, config?: Config): string | null | undefined;
 export declare function getUserFromHttp(headers: Headers, config: Config): string | null | undefined;
+export declare function makeBasicHeaders(config: Config, opts?: RequestInit): Headers;
 export declare function _fetch(config: Config, path: string, opts?: RequestInit): Promise<Response | ResponseError>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@niledatabase/server",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0-alpha.40",
   "license": "MIT",
   "main": "./dist/index.js",
   "module": "./dist/server.esm.js",
@@ -74,5 +74,5 @@
     "jose": "^4.15.4",
     "pg": "^8.11.3"
   },
-  "gitHead": "52ad5379abd61930e2d984495cba8b4b8b5803c4"
+  "gitHead": "bf5933e46ee24dde9d4135fbc2e993b9e804a6b6"
 }

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;