JavaScript

Learn how to integrate Nile Auth with any JavaScript backend framework. This guide shows a quickstart example for Node.js to help you get started using the Nile Auth SDK with your backend. In full-stack applications, user signup, authentication and even user profile UI can be handled automatically by the built-in routes and UI components. However, depending on your application’s requirements, you may need to use the SDK to directly call user management APIs in Nile Auth. This quickstart example shows how to do this. For more details on the Nile Auth JavaScript SDK, see the Nile Auth JS SDK documentation.

​

Quickstart

Nile SDK has APIs for working with users, tenants and sessions. In the example below, we’ll create a new user, login as that user, get and update the user’s profile information. We’ll then create a new tenant for that user, list users in the tenant and delete the tenant. Finally, we’ll show how to use the SDK to protect a route by checking if the user is authenticated and sign the user out.

mkdir my-project
cd my-project
npm init -y

npm install @niledatabase/server

import { Nile } from '@niledatabase/server';

const nile = await Nile({
  // debug: true  // Enable detailed logging
});

NILEDB_USER=
NILEDB_PASSWORD=
NILEDB_API_URL=
NILEDB_POSTGRES_URL=

console.log("Creating user:");
const user = await nile.api.users.createUser({
    email: 'test@test.com',
    password: 'password'
});

try {
  const loginBody = {
      email: 'test@test.com',
      password: 'password'
  }
  console.info(`logging in using ${loginBody.email} ${loginBody.password}`);
  await nile.api.login(loginBody);
} catch (err) {
  console.error("Failed to login", err);
  process.exit(1);
}

console.log("Getting user's profile information:");
const me = await nile.api.users.me();
console.log(me);

console.log("Updating user's profile information:");
const update = {
  name: 'updatedName',
};
const updatedUser = await nile.api.users.updateMe(update);
console.log(updatedUser);

console.log("Creating tenant:");
const tenant = await nile.api.tenants.createTenant({
    name: 'tenantName'
});
console.log(tenant);

console.log("Updating tenant:");
nile.tenantId = tenant.id; // `tenant` object is returned from the `tenants.create` call in the previous step
const updatedTenant = await nile.api.tenants.updateTenant({
    name: 'newTenantName'
});
console.log(updatedTenant);

nile.tenantId = tenant.id;
console.log("Listing users in a tenant:");
const users = await nile.api.users.listUsers();
console.log(users);

console.log("Deleting tenant:");
nile.tenantId = tenant.id; 
await nile.api.tenants.deleteTenant();

console.log("Checking if a user is authenticated:");
const session = await nile.api.auth.getSession();
if (!session) {
  // in real example, you would return a 401 Unauthorized error
  console.error('User is not authenticated');
  process.exit(1);
}

// in real example, you would allow the user to do something that only authenticated users can do
// and then return a 200 OK response and maybe some data
console.log('User is authenticated', session.user);
console.log('We can now allow them to do something that only authenticated users can do');

console.log("Signing out a user:");
const res = await nile.api.auth.signOut();
if (res.url) {
  // In real example, you would redirect the user to the URL in the response
  console.log('Redirect to:', res.url);
}

node nile-qs.js

​

Security Considerations

• Never log or otherwise store user passwords in plain text
• Never log or store authentication tokens or session information
• Always validate and sanitize user input before passing it to Nile Auth APIs
• Avoid exposing detailed error messages to clients that might reveal system information
• Implement rate limiting for authentication attempts to prevent brute force attacks
• Log authentication failures and suspicious activities for monitoring
• Implement appropriate error responses that don’t leak sensitive information
• Keep your Nile SDK and dependencies up to date

​

For more information and examples

• SDK Reference
• Express.js Quickstart
• Next.js Quickstart
• Remix Quickstart

​

Best Practices

1. Error Handling Implement comprehensive error handling for all authentication flows. Return user-friendly error messages while logging detailed errors server-side. Use try-catch blocks around all authentication operations.

2. Session Management Regularly validate sessions. Implement proper session cleanup on logout. Use secure session storage methods.

3. Code Organization Separate authentication logic into dedicated middleware. Create reusable authentication utilities. Keep configuration in environment variables.

4. Testing Test authentication flows thoroughly. Include both success and failure scenarios. Mock external authentication providers in tests.

​

Troubleshooting

​

Common Issues

1. Invalid Session Token Verify that user authentication was successful. Verify the token is being properly passed in requests. Check if the session has expired. Ensure the token format is correct.

2. CORS Issues Ensure your server is configured to accept requests from your client domain. Check that necessary CORS headers are being set.

3. User Creation Failures Make sure you properly handle common user mistakes: Validate email format before submission and check for duplicate email address error that may be returned.

​

Debug Tips

1. Enable debug logging:

const nile = new Nile({
  debug: true  // Enable detailed logging
});

2. Monitor network requests in your browser’s developer tools
3. Check server logs for detailed error messages
4. Verify environment variables are properly set

For additional support, visit our Discord community or GitHub discussions.