@niledatabase/server 4.0.0-alpha.1 → 4.0.0-alpha.11

package/README.md

@@ -1,39 +1,83 @@
-# @niledatabase/server
+<p align="center">
+  <img width="1434" alt="Screen Shot 2024-09-18 at 9 20 04 AM" src="https://github.com/user-attachments/assets/20585883-5cdc-4f15-93d3-dc150e87bc11">
+</p>
 
-Consolidates the API and DB for working with Nile.
+---
 
-## Usage
+# Nile's Server-Side SDK
 
-### With configuration object
+This package (`@niledatabase/server`) is part of [Nile's Javascript SDK](https://github.com/niledatabase/nile-js/tree/main).
 
-```ts
-import Nile from '@niledatabase/server';
+Nile's server-side Javascript package provides:
 
-const nile = await Nile({
-  user: 'username',
-  password: 'password',
-});
+- 🔐 Methods for working with Nile's user and tenant APIs
+- 🔑 Generated routes for authentication
+- 🔍 SQL query execution with tenant and user context management
 
-await nile.api.createTenant({ name: 'name' });
+**Nile is a Postgres platform that decouples storage from compute, virtualizes tenants, and supports vertical and horizontal scaling globally to ship B2B applications fast while being safe with limitless scale.** All B2B applications are multi-tenant. A tenant/customer is primarily a company, an organization, or a workspace in your product that contains a group of users. A B2B application provides services to multiple tenants. Tenant is the basic building block of all B2B applications.
 
-await nile.db.query('select * from todo');
+## Usage
+
+### Installation
+
+```ts
+npm install @niledatabase/server 
 ```
 
-### With env vars
+### Initialize SDK with env vars
+
+The recommended way to initialize Nile SDK is with `.env` file. You can copy the environment variables from [Nile console](https://console.thenile.dev). It should look similar to this:
 
 ```bash
 NILEDB_USER=username
 NILEDB_PASSWORD=password
+NILEDB_API_URL=https://us-west-2.api.thenile.dev/v2/databases/DBID
+NILEDB_POSTGRES_URL=postgres://us-west-2.db.thenile.dev:5432/dbname
 ```
 
 ```ts
 import Nile from '@niledatabase/server';
 
 const nile = await Nile();
+```
+
+### Initialize SDK with configuration object
 
-await nile.api.createTenant({ name: 'name' });
+```ts
+import Nile from '@niledatabase/server';
+
+const nile = await Nile({
+  user: 'username',
+  password: 'password',
+  debug: true
+});
+```
 
-await nile.db.query('select * from todo');
+### Call Nile APIs
+
+```typescript
+const tenant = await nile.api.tenants.createTenant(tenantName);
+if (tenant instanceof Response) {
+  const err = await tenant.text()
+  console.log("ERROR creating tenant: ", tenant, err);
+  return { message: "Error creating tenant" };
+}
+nile.tenant_id = tenant.id // set context
+// Get tenant name doesn't need any input parameters 
+// because it uses the tenant ID and user token from the context
+const checkTenant = await tenantNile.api.tenants.getTenant();
+```
+
+### Query the database
+
+```typescript
+  nile.tenant_id = tenant.id // set context
+
+  const todos = await nile.db
+    .query("select * from todos order by title")
+    .catch((e: Error) => {
+      console.error(e);
+    }); // no need for where clause if you previously set Nile context
 ```
 
 ## Initialization
@@ -59,3 +103,9 @@ Configuration passed to `Server` takes precedence over `.env` vars.
 | 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.                                         |
+
+## Learn more
+
+- You can learn more about Nile and the SDK in [https://thenile.dev/docs]
+- You can find detailed code examples in [our main repo](https://github.com/niledatabase/niledatabase)
+- Nile SDK interacts with APIs in Nile Auth service. You can learn more about it in the [repository](https://github.com/niledatabase/nile-auth) and the [docs](https://thenile.dev/docs/auth)

package/dist/index.d.mts

@@ -1,34 +1,47 @@
 import pg, { PoolConfig, PoolClient } from 'pg';
 
-type ConfigRoutes = {
-    SIGNIN?: string;
-    SESSION?: string;
-    PROVIDERS?: string;
-    CSRF?: string;
-    CALLBACK?: string;
-    SIGNOUT?: string;
-    ME?: string;
-    ERROR?: string;
-    TENANTS?: string;
-    TENANT_USERS?: string;
-    USERS?: string;
+type Routes = {
+    SIGNIN: string;
+    SESSION: string;
+    PROVIDERS: string;
+    CSRF: string;
+    CALLBACK: string;
+    SIGNOUT: string;
+    ERROR: string;
+    ME: string;
+    USERS: string;
+    TENANTS: string;
+    TENANT: string;
+    TENANT_USER: string;
+    TENANT_USERS: string;
+    SIGNUP: string;
+    VERIFY_REQUEST: string;
+    PASSWORD_RESET: string;
+    LOG: string;
 };
+
 type ApiParams = {
     basePath?: string | undefined;
     cookieKey?: string;
     token?: string | undefined;
     callbackUrl?: string | undefined;
+    routes?: Partial<Routes>;
+    routePrefix?: string | undefined;
+    secureCookies?: boolean;
 };
 declare class ApiConfig {
     cookieKey?: string;
     basePath?: string | undefined;
+    routes?: Partial<Routes>;
+    routePrefix?: string;
+    secureCookies?: boolean;
     /**
      * The client side callback url. Defaults to nothing (so nile.origin will be it), but in the cases of x-origin, you want to set this explicitly to be sure nile-auth does the right thing
      * If this is set, any `callbackUrl` from the client will be ignored.
      */
     callbackUrl?: string;
     private _token?;
-    constructor({ basePath, cookieKey, token, callbackUrl }: ApiParams);
+    constructor(config?: ServerConfig, logger?: string);
     get token(): string | undefined;
     set token(value: string | undefined);
 }
@@ -37,10 +50,7 @@ declare class Config {
     password: string;
     databaseId: string;
     databaseName: string;
-    routePrefix?: string;
-    routes?: ConfigRoutes;
     logger?: LoggerType;
-    secureCookies?: boolean | undefined;
     debug: boolean;
     db: NilePoolConfig;
     api: ApiConfig;
@@ -76,7 +86,6 @@ type ServerConfig = {
     userId?: string | null | undefined;
     debug?: boolean;
     configureUrl?: string;
-    secureCookies?: boolean;
     db?: NilePoolConfig;
     api?: ApiParams;
     logger?: LoggerType;
@@ -157,26 +166,6 @@ type ActiveSession = {
     };
 };
 
-type Routes = {
-    SIGNIN: string;
-    SESSION: string;
-    PROVIDERS: string;
-    CSRF: string;
-    CALLBACK: string;
-    SIGNOUT: string;
-    ERROR: string;
-    ME: string;
-    USERS: string;
-    TENANTS: string;
-    TENANT: string;
-    TENANT_USER: string;
-    TENANT_USERS: string;
-    SIGNUP: string;
-    VERIFY_REQUEST: string;
-    PASSWORD_RESET: string;
-    LOG: string;
-};
-
 interface NileBody<R, B> {
     readonly body: ReadableStream<Uint8Array> | null | B;
     readonly bodyUsed: boolean;

package/dist/index.d.ts

@@ -1,34 +1,47 @@
 import pg, { PoolConfig, PoolClient } from 'pg';
 
-type ConfigRoutes = {
-    SIGNIN?: string;
-    SESSION?: string;
-    PROVIDERS?: string;
-    CSRF?: string;
-    CALLBACK?: string;
-    SIGNOUT?: string;
-    ME?: string;
-    ERROR?: string;
-    TENANTS?: string;
-    TENANT_USERS?: string;
-    USERS?: string;
+type Routes = {
+    SIGNIN: string;
+    SESSION: string;
+    PROVIDERS: string;
+    CSRF: string;
+    CALLBACK: string;
+    SIGNOUT: string;
+    ERROR: string;
+    ME: string;
+    USERS: string;
+    TENANTS: string;
+    TENANT: string;
+    TENANT_USER: string;
+    TENANT_USERS: string;
+    SIGNUP: string;
+    VERIFY_REQUEST: string;
+    PASSWORD_RESET: string;
+    LOG: string;
 };
+
 type ApiParams = {
     basePath?: string | undefined;
     cookieKey?: string;
     token?: string | undefined;
     callbackUrl?: string | undefined;
+    routes?: Partial<Routes>;
+    routePrefix?: string | undefined;
+    secureCookies?: boolean;
 };
 declare class ApiConfig {
     cookieKey?: string;
     basePath?: string | undefined;
+    routes?: Partial<Routes>;
+    routePrefix?: string;
+    secureCookies?: boolean;
     /**
      * The client side callback url. Defaults to nothing (so nile.origin will be it), but in the cases of x-origin, you want to set this explicitly to be sure nile-auth does the right thing
      * If this is set, any `callbackUrl` from the client will be ignored.
      */
     callbackUrl?: string;
     private _token?;
-    constructor({ basePath, cookieKey, token, callbackUrl }: ApiParams);
+    constructor(config?: ServerConfig, logger?: string);
     get token(): string | undefined;
     set token(value: string | undefined);
 }
@@ -37,10 +50,7 @@ declare class Config {
     password: string;
     databaseId: string;
     databaseName: string;
-    routePrefix?: string;
-    routes?: ConfigRoutes;
     logger?: LoggerType;
-    secureCookies?: boolean | undefined;
     debug: boolean;
     db: NilePoolConfig;
     api: ApiConfig;
@@ -76,7 +86,6 @@ type ServerConfig = {
     userId?: string | null | undefined;
     debug?: boolean;
     configureUrl?: string;
-    secureCookies?: boolean;
     db?: NilePoolConfig;
     api?: ApiParams;
     logger?: LoggerType;
@@ -157,26 +166,6 @@ type ActiveSession = {
     };
 };
 
-type Routes = {
-    SIGNIN: string;
-    SESSION: string;
-    PROVIDERS: string;
-    CSRF: string;
-    CALLBACK: string;
-    SIGNOUT: string;
-    ERROR: string;
-    ME: string;
-    USERS: string;
-    TENANTS: string;
-    TENANT: string;
-    TENANT_USER: string;
-    TENANT_USERS: string;
-    SIGNUP: string;
-    VERIFY_REQUEST: string;
-    PASSWORD_RESET: string;
-    LOG: string;
-};
-
 interface NileBody<R, B> {
     readonly body: ReadableStream<Uint8Array> | null | B;
     readonly bodyUsed: boolean;

package/dist/index.js

@@ -92,8 +92,8 @@ async function request(url, _init, config) {
       String(request2.headers.get(X_NILE_TENANT))
     );
   }
-  if ("secureCookies" in config && config.secureCookies != null) {
-    updatedHeaders.set(X_NILE_SECURECOOKIES, String(config.secureCookies));
+  if (config.api.secureCookies != null) {
+    updatedHeaders.set(X_NILE_SECURECOOKIES, String(config.api.secureCookies));
   }
   updatedHeaders.set("host", requestUrl.host);
   if (config.api.callbackUrl) {
@@ -184,7 +184,7 @@ var getSecureCookies = (cfg) => {
   if (stringCheck(process.env.NILEDB_SECURECOOKIES)) {
     return Boolean(process.env.NILEDB_SECURECOOKIES);
   }
-  return config?.secureCookies;
+  return config?.api?.secureCookies;
 };
 var getDatabaseId = (cfg) => {
   const { config, logger } = cfg;
@@ -308,6 +308,19 @@ var getTenantId = (cfg) => {
   }
   return null;
 };
+var getCookieKey = (cfg) => {
+  const { config, logger } = cfg;
+  const { info } = Logger(config, "[cookieKey]");
+  if (stringCheck(config?.api?.cookieKey)) {
+    logger && info(`${logger}[config] ${config?.api?.cookieKey}`);
+    return String(config?.api?.cookieKey);
+  }
+  if (stringCheck(process.env.NILEDB_COOKIE_KEY)) {
+    logger && info(`${logger}[NILEDB_COOKIE_KEY] ${process.env.NILEDB_COOKIE_KEY}`);
+    return String(process.env.NILEDB_COOKIE_KEY);
+  }
+  return "token";
+};
 var getBasePath = (cfg) => {
   const { config, logger } = cfg;
   const { warn, info, error } = Logger(config, "[basePath]");
@@ -410,17 +423,24 @@ var stringCheck = (str) => {
 var ApiConfig = class {
   cookieKey;
   basePath;
+  routes;
+  routePrefix;
+  secureCookies;
   /**
    * The client side callback url. Defaults to nothing (so nile.origin will be it), but in the cases of x-origin, you want to set this explicitly to be sure nile-auth does the right thing
    * If this is set, any `callbackUrl` from the client will be ignored.
    */
   callbackUrl;
   _token;
-  constructor({ basePath, cookieKey, token, callbackUrl }) {
-    this.basePath = basePath;
-    this.cookieKey = cookieKey;
-    this.callbackUrl = callbackUrl;
-    this._token = token;
+  constructor(config, logger) {
+    const envVarConfig = { config, logger };
+    this.cookieKey = getCookieKey(envVarConfig);
+    this._token = getToken(envVarConfig);
+    this.callbackUrl = getCallbackUrl(envVarConfig);
+    this.secureCookies = getSecureCookies(envVarConfig);
+    this.basePath = getBasePath(envVarConfig);
+    this.routes = config?.api?.routes;
+    this.routePrefix = config?.api?.routePrefix;
   }
   get token() {
     return this._token;
@@ -434,10 +454,7 @@ var Config = class {
   password;
   databaseId;
   databaseName;
-  routePrefix;
-  routes;
   logger;
-  secureCookies;
   debug;
   db;
   api;
@@ -472,23 +489,15 @@ var Config = class {
         );
       }
     }
-    this.secureCookies = getSecureCookies(envVarConfig);
     this.databaseId = getDatabaseId(envVarConfig);
     this.databaseName = getDatabaseName(envVarConfig);
     this._tenantId = getTenantId(envVarConfig);
     this.debug = Boolean(config?.debug);
     this._userId = config?.userId;
-    const callbackUrl = config?.api?.callbackUrl ?? getCallbackUrl(envVarConfig);
-    const basePath = getBasePath(envVarConfig);
     const { host, port, ...dbConfig } = config?.db ?? {};
     const configuredHost = host ?? getDbHost(envVarConfig);
     const configuredPort = port ?? getDbPort(envVarConfig);
-    this.api = new ApiConfig({
-      basePath,
-      cookieKey: config?.api?.cookieKey ?? "token",
-      token: getToken({ config }),
-      callbackUrl
-    });
+    this.api = new ApiConfig(config, logger);
     this.db = {
       user: this.user,
       password: this.password,
@@ -506,18 +515,12 @@ var Config = class {
       config
     };
     const { host, port, ...dbConfig } = config.db ?? {};
-    const callbackUrl = config?.api?.callbackUrl ?? getCallbackUrl(envVarConfig);
     let configuredHost = host ?? getDbHost(envVarConfig);
     const configuredPort = port ?? getDbPort(envVarConfig);
     let basePath = getBasePath(envVarConfig);
     if (configuredHost && this.databaseName && this.databaseId && basePath) {
       info("Already configured, aborting fetch");
-      this.api = new ApiConfig({
-        basePath,
-        cookieKey: config?.api?.cookieKey ?? "token",
-        token: getToken({ config }),
-        callbackUrl
-      });
+      this.api = new ApiConfig(config);
       this.db = {
         user: this.user,
         password: this.password,
@@ -602,12 +605,7 @@ var Config = class {
         configuredHost = dburl.hostname;
       }
     }
-    this.api = new ApiConfig({
-      basePath,
-      cookieKey: config?.api?.cookieKey ?? "token",
-      token: getToken({ config }),
-      callbackUrl
-    });
+    this.api = new ApiConfig(config);
     this.db = {
       user: this.user,
       password: this.password,
@@ -1008,8 +1006,8 @@ function makeBasicHeaders(config, opts) {
       headers.set("Authorization", `Bearer ${getToken({ config })}`);
     }
   }
-  if ("secureCookies" in config && config.secureCookies != null) {
-    headers.set(X_NILE_SECURECOOKIES, String(config.secureCookies));
+  if (config && config.api.secureCookies != null) {
+    headers.set(X_NILE_SECURECOOKIES, String(config.api.secureCookies));
   }
   return headers;
 }
@@ -1536,11 +1534,7 @@ function matches12(configRoutes, request2) {
 // src/api/routes/auth/password-reset.ts
 var key10 = "PASSWORD_RESET";
 async function route13(req, config) {
-  let url = proxyRoutes(config)[key10];
-  const { searchParams } = new URL(req.url);
-  if (searchParams.size > 0) {
-    url = `${url}?${searchParams.toString()}`;
-  }
+  const url = proxyRoutes(config)[key10];
   const res = await request(
     url,
     {
@@ -1892,7 +1886,7 @@ var Requester = class extends Config {
 var ORIGIN = "https://us-west-2.api.dev.thenile.dev";
 function serverLogin(config, handlers) {
   const { info, error, debug } = Logger(config, "[server side login]");
-  const routes = appRoutes(config.routePrefix);
+  const routes = appRoutes(config.api.routePrefix);
   return async function login({
     email,
     password
@@ -2226,8 +2220,8 @@ var Api = class {
     this.users = new Users(config);
     this.tenants = new Tenants(config);
     this.routes = {
-      ...appRoutes(config?.routePrefix),
-      ...config?.routes
+      ...appRoutes(config?.api.routePrefix),
+      ...config?.api.routes
     };
     this.handlers = Handlers(this.routes, config);
     this.paths = {