@niledatabase/server 1.0.0 → 2.1.0

package/README.md

@@ -4,25 +4,57 @@ Consolidates the API and DB for working with Nile.
 
 ## Usage
 
+### With configuration object
+
 ```ts
 import Server from '@niledatabase/server';
 
-const connection = {
-  user: process.env.NILE_USER,
-  password: process.env.NILE_PASSWORD,
-};
 const nile = Server({
-  workspace: String(process.env.NILE_WORKSPACE),
-  database: String(process.env.NILE_DATABASE),
-  api: {
-    basePath: String(process.env.BASE_PATH),
-  },
-  db: {
-    connection,
-  },
+  user: 'username',
+  password: 'password',
 });
 
-await nile.api.createTenant({name: 'name'})
+await nile.api.createTenant({ name: 'name' });
+
+await nile.db.query('select * from todo');
+```
+
+### With env vars
+
+```bash
+NILEDB_USER=username
+NILEDB_PASSWORD=password
+```
+
+```ts
+import Server from '@niledatabase/server';
+
+const nile = Server();
 
-await nile.db.("todo").withTenant('tenant-id');
+await nile.api.createTenant({ name: 'name' });
+
+await nile.db.query('select * from todo');
 ```
+
+## Autoconfiguration
+
+In addition to `user` and `password`, a fully configured SDK must also have values for `db.host`, `databaseName`, and `databaseId`. If the values are not provided in either the `.env` file or the instance configuration, the SDK will automatically phone home to configure itself. For production, it is recommended to set those values.
+
+## Configuration
+
+Configuration passed to `Server` takes precedence over `.env` vars.
+
+| Property      | Type         | .env var        | Description                                                              |
+| ------------- | ------------ | --------------- | ------------------------------------------------------------------------ |
+| user          | `string`     | NILEDB_USER     | Required. Username for database authentication.                          |
+| password      | `string`     | NILEDB_PASSWORD | Required. Password for database authentication.                          |
+| databaseId    | `string`     | NILEDB_ID       | ID of the database.                                                      |
+| databaseName  | `string`     | NILEDB_NAME     | Name of the database.                                                    |
+| tenantId      | `string`     | NILEDB_TENANT   | ID of the tenant associated.                                             |
+| userId        | `string`     |                 | ID of the user associated.                                               |
+| db            | `PoolConfig` |                 | Configuration object for [pg.Pool](https://node-postgres.com/apis/pool). |
+| api           | `object`     |                 | Configuration object for API settings.                                   |
+| api.basePath  | `string`     | NILEDB_API      | Base host for API for a specific region. Default is `api.thenile.dev`.   |
+| api.cookieKey | `string`     |                 | Key for API cookie. Default is `token`.                                  |
+| api.token     | `string`     | NILEDB_TOKEN    | Token for API authentication. Mostly for debugging.                      |
+| debug         | `boolean`    |                 | Flag for enabling debug logging.                                         |

package/dist/Server.d.ts

@@ -1,9 +1,9 @@
+import { Pool } from 'pg';
 import { InstanceConfig, ServerConfig } from './types';
 import { Config } from './utils/Config';
 import Auth from './auth';
 import Users from './users';
 import Tenants from './tenants';
-import { NileDatabaseI } from './db';
 type Api = {
     auth: Auth;
     users: Users;
@@ -16,15 +16,14 @@ declare class Server {
     private servers;
     constructor(config?: ServerConfig);
     setConfig(cfg: Config): void;
-    set database(val: string | void);
-    set workspace(val: string | void);
+    set databaseId(val: string | void);
     get userId(): string | undefined | null;
     set userId(userId: string | undefined | null);
     get tenantId(): string | undefined | null;
     set tenantId(tenantId: string | undefined | null);
     get token(): string | undefined | null;
     set token(token: string | undefined | null);
-    get db(): NileDatabaseI;
+    get db(): Pool;
     /**
      * A utility function if you want to manage different NileDB instances yourself
      * returns the global Server object, an existing server that's already been configured,
@@ -32,5 +31,5 @@ declare class Server {
      */
     getInstance(config: InstanceConfig): Server;
 }
-export default function Nile(config: ServerConfig): Server;
+export default function Nile(config?: ServerConfig): Server;
 export {};

package/dist/auth/index.d.ts

@@ -1,20 +1,39 @@
-import { RestModels } from '@niledatabase/js';
 import { Config } from '../utils/Config';
 import { NileRequest, NileResponse } from '../utils/Requester';
+import { CreateBasicUserRequest, LoginUserResponse } from '../users';
+export interface TenantSSORegistration {
+    configUrl: string;
+    clientId: string;
+    clientSecret: string;
+    redirectURI: string;
+    emailDomains: Array<string>;
+    enabled?: boolean;
+}
+export interface SSOProvider {
+    readonly id?: string;
+    tenantId?: string;
+    provider?: string;
+    configUrl: string;
+    clientSecret?: string;
+    clientId: string;
+    redirectURI: string;
+    emailDomains?: Array<string>;
+    enabled?: boolean;
+}
 export default class Auth extends Config {
     constructor(config: Config);
     get loginUrl(): string;
-    login: (req: NileRequest<RestModels.CreateBasicUserRequest>, init?: RequestInit) => NileResponse<RestModels.LoginUserResponse>;
-    loginSSO: (redirectUrl: string) => (req: NileRequest<unknown>) => NileResponse<RestModels.TenantSSORegistration[]>;
+    login: (req: NileRequest<CreateBasicUserRequest>, init?: RequestInit) => NileResponse<LoginUserResponse>;
+    loginSSO: (redirectUrl: string) => (req: NileRequest<unknown>) => NileResponse<Response>;
     loginSSOUrl: (provider: string) => string;
     get signUpUrl(): string;
-    signUp: (req: NileRequest<RestModels.CreateBasicUserRequest>, init?: RequestInit) => NileResponse<RestModels.LoginUserResponse>;
+    signUp: (req: NileRequest<CreateBasicUserRequest>, init?: RequestInit) => NileResponse<LoginUserResponse>;
     updateProviderUrl(providerName: string): string;
     get listTenantProvidersUrl(): string;
-    listTenantProviders: (req: NileRequest<void | Headers>, init?: RequestInit) => NileResponse<RestModels.TenantSSORegistration[]>;
-    createProvider: (req: NileRequest<RestModels.RegisterTenantSSORequest>, init?: RequestInit) => NileResponse<RestModels.TenantSSORegistration>;
-    updateProvider: (req: NileRequest<RestModels.RegisterTenantSSORequest>, init?: RequestInit) => NileResponse<RestModels.TenantSSORegistration>;
+    listTenantProviders: (req: NileRequest<void | Headers>, init?: RequestInit) => NileResponse<TenantSSORegistration[]>;
+    createProvider: (req: NileRequest<SSOProvider>, init?: RequestInit) => NileResponse<TenantSSORegistration>;
+    updateProvider: (req: NileRequest<SSOProvider>, init?: RequestInit) => NileResponse<TenantSSORegistration>;
     providerUrl(email?: undefined | string): string;
-    listProviders: (req: NileRequest<void | RestModels.CreateBasicUserRequest>, init?: RequestInit) => NileResponse<RestModels.TenantSSORegistration[]>;
+    listProviders: (req: NileRequest<void | CreateBasicUserRequest>, init?: RequestInit) => NileResponse<TenantSSORegistration[]>;
     getSSOCallbackUrl: (param: Headers | string) => string;
 }

package/dist/db/DBManager.d.ts

@@ -1,8 +1,9 @@
+import { Pool } from 'pg';
 import { Config } from '../utils/Config';
-import NileDatabase, { NileDatabaseI } from './NileInstance';
+import NileDatabase from './NileInstance';
 export default class DBManager {
     connections: Map<string, NileDatabase>;
     private makeId;
     constructor(config: Config);
-    getConnection(config: Config): NileDatabaseI;
+    getConnection(config: Config): Pool;
 }

package/dist/db/NileInstance.d.ts

@@ -1,15 +1,14 @@
 /// <reference types="node" />
-import { Knex } from 'knex';
+import { Pool } from 'pg';
 import { Config } from '../utils/Config';
 declare class NileDatabase {
-    knex: Knex;
+    pool: Pool;
     tenantId?: undefined | null | string;
     userId?: undefined | null | string;
     id: string;
-    config: any;
+    config: Config;
     timer: NodeJS.Timeout | undefined;
     constructor(config: Config, id: string);
     startTimeout(): void;
 }
-export type NileDatabaseI = (table?: string) => Knex;
 export default NileDatabase;

package/dist/db/index.d.ts

@@ -1,2 +1 @@
 export { default } from './DBManager';
-export { NileDatabaseI } from './NileInstance';