@urbackend/sdk 0.1.0 → 0.1.1

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": true,
+  "trailingComma": "all",
+  "singleQuote": true,
+  "printWidth": 100,
+  "tabWidth": 2
+}

package/README.md

@@ -1,82 +1,85 @@
-# urbackend-sdk
-
-Official TypeScript SDK for [urBackend](https://urbackend.bitbros.in) — the instant Backend-as-a-Service for frontend developers.
-
-## Installation
-npm install @urbackend/sdk
-
-## Quick Start
-```javascript
-import urBackend from '@urbackend/sdk';
-
-const client = urBackend({ apiKey: 'YOUR_API_KEY' });
-
-// Auth
-await client.auth.signUp({ email, password, name });
-const { token } = await client.auth.login({ email, password });
-
-// Database (collections auto-created on first insert)
-await client.db.insert('products', { name: 'Chair', price: 99 });
-await client.db.getAll('products');
-await client.db.update('products', id, { price: 79 });
-await client.db.delete('products', id);
-
-// Storage
-const { url } = await client.storage.upload(file);
-```
-
-## API Reference
-
-### Client initialization
-`urBackend({ apiKey: string, baseUrl?: string })`
-
-### Auth
-| Method | Params | Returns |
-|--------|--------|---------|
-| signUp | { email, password, name? } | AuthUser |
-| login  | { email, password } | { token, user } |
-| me     | token? | AuthUser |
-| logout | — | void |
-
-### Database
-| Method | Params | Returns |
-|--------|--------|---------|
-| getAll<T> | collection | T[] |
-| getOne<T> | collection, id | T |
-| insert<T> | collection, data | T |
-| update<T> | collection, id, data | T |
-| delete | collection, id | { deleted: boolean } |
-
-### Storage
-| Method | Params | Returns |
-|--------|--------|---------|
-| upload | file, filename? | { url, path } |
-| deleteFile | path | { deleted: boolean } |
-
-## Error Handling
-```javascript
-import { AuthError, NotFoundError, RateLimitError } from '@urbackend/sdk';
-
-try {
-  await client.db.getOne('products', id);
-} catch (e) {
-  if (e instanceof NotFoundError) console.log('Not found');
-  if (e instanceof RateLimitError) console.log('Slow down');
-}
-```
-
-## TypeScript Support
-```typescript
-interface Product { _id: string; name: string; price: number; }
-const products = await client.db.getAll<Product>('products');
-```
-
-## Limits
-- Rate limit: 100 requests / 15 mins per IP
-- Database: 50 MB per project
-- Storage: 100 MB per project
-- File upload: 5 MB per file
-
-## Security
-⚠️ Never expose your API key in client-side/browser code.
-Use environment variables: `process.env.URBACKEND_API_KEY`
+# urbackend-sdk
+
+Official TypeScript SDK for [urBackend](https://urbackend.bitbros.in) — the instant Backend-as-a-Service for frontend developers.
+
+## Installation
+npm install @urbackend/sdk
+
+## Quick Start
+```javascript
+import urBackend from '@urbackend/sdk';
+
+const client = urBackend({ apiKey: 'YOUR_API_KEY' });
+
+// Auth
+await client.auth.signUp({ email, password, name });
+await client.auth.login({ email, password });
+await client.auth.me();
+
+// Database — collections are auto-created on first insert
+await client.db.insert('products', { name: 'Chair', price: 99 });
+await client.db.getAll('products');
+await client.db.getOne('products', id);
+await client.db.update('products', id, { price: 79 });
+await client.db.delete('products', id);
+
+// Storage
+await client.storage.upload(file);
+await client.storage.deleteFile(path);
+```
+
+## API Reference
+
+### Client initialization
+`urBackend({ apiKey: string, baseUrl?: string })`
+
+### Auth
+| Method | Params | Returns |
+|--------|--------|---------|
+| signUp | { email, password, name? } | AuthUser |
+| login  | { email, password } | { token, user } |
+| me     | token? | AuthUser |
+| logout | — | void |
+
+### Database
+| Method | Params | Returns |
+|--------|--------|---------|
+| getAll<T> | collection | T[] |
+| getOne<T> | collection, id | T |
+| insert<T> | collection, data | T |
+| update<T> | collection, id, data | T |
+| delete | collection, id | { deleted: boolean } |
+
+### Storage
+| Method | Params | Returns |
+|--------|--------|---------|
+| upload | file, filename? | { url, path } |
+| deleteFile | path | { deleted: boolean } |
+
+## Error Handling
+```javascript
+import { AuthError, NotFoundError, RateLimitError } from '@urbackend/sdk';
+
+try {
+  await client.db.getOne('products', id);
+} catch (e) {
+  if (e instanceof NotFoundError) console.log('Not found');
+  if (e instanceof RateLimitError) console.log('Slow down');
+}
+```
+
+## TypeScript Support
+```typescript
+interface Product { _id: string; name: string; price: number; }
+const products = await client.db.getAll<Product>('products');
+```
+
+## Limits
+- Rate limit: 100 requests / 15 mins per IP
+- Database: 50 MB per project
+- Storage: 100 MB per project
+- File upload: 5 MB per file
+
+## Security
+⚠️ Never expose your API key in client-side/browser code.
+Use environment variables: `process.env.URBACKEND_API_KEY`

package/eslint.config.js

@@ -0,0 +1,15 @@
+import eslint from '@eslint/js';
+import tseslint from 'typescript-eslint';
+
+export default tseslint.config(
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  {
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'error',
+    },
+  },
+  {
+    ignores: ['dist/**', 'node_modules/**', 'tests/**'],
+  },
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@urbackend/sdk",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Official TypeScript SDK for urBackend BaaS",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",
@@ -12,16 +12,11 @@
       "require": "./dist/index.cjs"
     }
   },
-  "files": [
-    "dist",
-    "README.md"
-  ],
   "scripts": {
     "build": "tsup",
     "test": "vitest run --coverage",
     "lint": "eslint src",
-    "format": "prettier --write \"src/**/*.ts\"",
-    "prepublishOnly": "npm run build && npm test"
+    "format": "prettier --write \"src/**/*.ts\""
   },
   "keywords": [
     "urbackend",
@@ -53,8 +48,5 @@
     "typescript": "^5.9.3",
     "typescript-eslint": "^8.57.2",
     "vitest": "^4.1.2"
-  },
-  "dependencies": {
-    "@urbackend/sdk": "^1.0.0"
   }
-}
+}

package/src/client.ts

@@ -0,0 +1,107 @@
+import { UrBackendConfig, RequestOptions } from './types';
+import { UrBackendError, parseApiError } from './errors';
+import { AuthModule } from './modules/auth';
+import { DatabaseModule } from './modules/database';
+import { StorageModule } from './modules/storage';
+
+export class UrBackendClient {
+  private apiKey: string;
+  private baseUrl: string;
+  private _auth?: AuthModule;
+  private _db?: DatabaseModule;
+  private _storage?: StorageModule;
+  private headers: Record<string, string>;
+
+  constructor(config: UrBackendConfig) {
+    this.apiKey = config.apiKey;
+    this.baseUrl = config.baseUrl || 'https://api.ub.bitbros.in';
+    this.headers = config.headers || {};
+
+    if (typeof window !== 'undefined') {
+      console.warn(
+        '⚠️ urbackend-sdk: Avoid exposing your SK-API key in client-side code(instead use pk_live key). This can lead to unauthorized access to your account and data.',
+      );
+    }
+  }
+
+  get auth(): AuthModule {
+    if (!this._auth) {
+      this._auth = new AuthModule(this);
+    }
+    return this._auth;
+  }
+
+  get db(): DatabaseModule {
+    if (!this._db) {
+      this._db = new DatabaseModule(this);
+    }
+    return this._db;
+  }
+
+  get storage(): StorageModule {
+    if (!this._storage) {
+      this._storage = new StorageModule(this);
+    }
+    return this._storage;
+  }
+
+  /**
+   * Internal request handler
+   */
+  public async request<T>(
+    method: string,
+    path: string,
+    options: RequestOptions = {},
+  ): Promise<T> {
+    const url = `${this.baseUrl}${path}`;
+    const headers: Record<string, string> = {
+      'x-api-key': this.apiKey,
+      'User-Agent': `urbackend-sdk-js/0.1.1`,
+      ...this.headers,
+    };
+
+    if (options.token) {
+      headers['Authorization'] = `Bearer ${options.token}`;
+    }
+
+    let requestBody: BodyInit | undefined;
+
+    if (options.isMultipart) {
+      // Fetch handles FormData content type and boundary
+      requestBody = options.body as FormData;
+    } else if (options.body) {
+      headers['Content-Type'] = 'application/json';
+      requestBody = JSON.stringify(options.body);
+    }
+
+    try {
+      const response = await fetch(url, {
+        method,
+        headers,
+        body: requestBody,
+      });
+
+      if (!response.ok) {
+        throw await parseApiError(response);
+      }
+
+      const contentType = response.headers.get('content-type');
+      if (contentType && contentType.includes('application/json')) {
+        const json = await response.json();
+        // The API returns { data, success, message }
+        return json.data !== undefined ? json.data : json;
+      }
+
+      return (await response.text()) as unknown as T;
+    } catch (error) {
+      if (error instanceof UrBackendError) {
+        throw error;
+      }
+      throw new UrBackendError(
+        error instanceof Error ? error.message : 'Network request failed',
+        0,
+        path,
+      );
+    }
+  }
+}

package/src/errors.ts

@@ -0,0 +1,90 @@
+export class UrBackendError extends Error {
+  constructor(
+    public message: string,
+    public statusCode: number,
+    public endpoint: string,
+  ) {
+    super(message);
+    this.name = 'UrBackendError';
+  }
+}
+
+export class AuthError extends UrBackendError {
+  constructor(message: string, statusCode: number, endpoint: string) {
+    super(message, statusCode, endpoint);
+    this.name = 'AuthError';
+  }
+}
+
+export class NotFoundError extends UrBackendError {
+  constructor(message: string, endpoint: string) {
+    super(message, 404, endpoint);
+    this.name = 'NotFoundError';
+  }
+}
+
+export class RateLimitError extends UrBackendError {
+  public retryAfter?: number;
+
+  constructor(message: string, endpoint: string, retryAfter?: number) {
+    super(message, 429, endpoint);
+    this.name = 'RateLimitError';
+    this.retryAfter = retryAfter;
+  }
+}
+
+export class StorageError extends UrBackendError {
+  constructor(message: string, statusCode: number, endpoint: string) {
+    super(message, statusCode, endpoint);
+    this.name = 'StorageError';
+  }
+}
+
+export class ValidationError extends UrBackendError {
+  constructor(message: string, endpoint: string) {
+    super(message, 400, endpoint);
+    this.name = 'ValidationError';
+  }
+}
+
+export async function parseApiError(response: Response): Promise<UrBackendError> {
+  const endpoint = new URL(response.url).pathname;
+  let message = 'An unexpected error occurred';
+  let data: unknown;
+
+  try {
+    data = await response.json();
+    if (typeof data === 'object' && data !== null && 'message' in data) {
+      message = (data as { message: string }).message || message;
+    }
+  } catch {
+    // If not JSON, use status text
+    message = response.statusText || message;
+  }
+
+  const status = response.status;
+
+  if (status === 401 || status === 403) {
+    return new AuthError(message, status, endpoint);
+  }
+
+  if (status === 404) {
+    return new NotFoundError(message, endpoint);
+  }
+
+  if (status === 429) {
+    const retryAfter = response.headers.get('Retry-After');
+    return new RateLimitError(message, endpoint, retryAfter ? parseInt(retryAfter, 10) : undefined);
+  }
+
+  if (status === 400) {
+    return new ValidationError(message, endpoint);
+  }
+
+  // Default for 5xx or other 4xx
+  if (endpoint.includes('/api/storage')) {
+    return new StorageError(message, status, endpoint);
+  }
+
+  return new UrBackendError(message, status, endpoint);
+}

package/src/index.ts

@@ -0,0 +1,13 @@
+import { UrBackendClient } from './client';
+import { UrBackendConfig } from './types';
+
+export * from './types';
+export * from './errors';
+export { UrBackendClient };
+
+/**
+ * Factory function to create a new urBackend client
+ */
+export default function urBackend(config: UrBackendConfig): UrBackendClient {
+  return new UrBackendClient(config);
+}

package/src/modules/auth.ts

@@ -0,0 +1,47 @@
+import { UrBackendClient } from '../client';
+import { AuthUser, AuthResponse, SignUpPayload, LoginPayload } from '../types';
+import { AuthError } from '../errors';
+
+export class AuthModule {
+  private sessionToken?: string;
+
+  constructor(private client: UrBackendClient) {}
+
+  /**
+   * Create a new user account
+   */
+  public async signUp(payload: SignUpPayload): Promise<AuthUser> {
+    return this.client.request<AuthUser>('POST', '/api/userAuth/signup', { body: payload });
+  }
+
+  /**
+   * Log in an existing user and store the session token
+   */
+  public async login(payload: LoginPayload): Promise<AuthResponse> {
+    const response = await this.client.request<AuthResponse>('POST', '/api/userAuth/login', {
+      body: payload,
+    });
+    this.sessionToken = response.token;
+    return response;
+  }
+
+  /**
+   * Get the current authenticated user's profile
+   */
+  public async me(token?: string): Promise<AuthUser> {
+    const activeToken = token || this.sessionToken;
+
+    if (!activeToken) {
+      throw new AuthError('Authentication token is required for /me endpoint', 401, '/api/userAuth/me');
+    }
+
+    return this.client.request<AuthUser>('GET', '/api/userAuth/me', { token: activeToken });
+  }
+
+  /**
+   * Clear the local session token
+   */
+  public logout(): void {
+    this.sessionToken = undefined;
+  }
+}

package/src/modules/database.ts

@@ -0,0 +1,53 @@
+import { UrBackendClient } from '../client';
+import { DocumentData, InsertPayload, UpdatePayload } from '../types';
+import { NotFoundError } from '../errors';
+
+export class DatabaseModule {
+  constructor(private client: UrBackendClient) {}
+
+  /**
+   * Fetch all documents from a collection
+   */
+  public async getAll<T extends DocumentData>(collection: string): Promise<T[]> {
+    try {
+      return await this.client.request<T[]>('GET', `/api/data/${collection}`);
+    } catch (e) {
+      if (e instanceof NotFoundError) {
+        return [] as T[];
+      }
+      throw e;
+    }
+  }
+
+  /**
+   * Fetch a single document by its ID
+   */
+  public async getOne<T extends DocumentData>(collection: string, id: string): Promise<T> {
+    return this.client.request<T>('GET', `/api/data/${collection}/${id}`);
+  }
+
+  /**
+   * Insert a new document into a collection
+   */
+  public async insert<T extends DocumentData>(collection: string, data: InsertPayload): Promise<T> {
+    return this.client.request<T>('POST', `/api/data/${collection}`, { body: data });
+  }
+
+  /**
+   * Update an existing document by its ID
+   */
+  public async update<T extends DocumentData>(
+    collection: string,
+    id: string,
+    data: UpdatePayload,
+  ): Promise<T> {
+    return this.client.request<T>('PUT', `/api/data/${collection}/${id}`, { body: data });
+  }
+
+  /**
+   * Delete a document by its ID
+   */
+  public async delete(collection: string, id: string): Promise<{ deleted: boolean }> {
+    return this.client.request<{ deleted: boolean }>('DELETE', `/api/data/${collection}/${id}`);
+  }
+}

package/src/modules/storage.ts

@@ -0,0 +1,41 @@
+/// <reference lib="dom" />
+import { UrBackendClient } from '../client';
+import { UploadResponse } from '../types';
+
+export class StorageModule {
+  constructor(private client: UrBackendClient) {}
+
+  /**
+   * Upload a file to storage
+   */
+  public async upload(file: unknown, filename?: string): Promise<UploadResponse> {
+    const formData = new FormData();
+
+    if (
+      typeof window === 'undefined' &&
+      typeof Buffer !== 'undefined' &&
+      Buffer.isBuffer(file)
+    ) {
+      // In Node.js environment, convert Buffer to Blob for standard FormData
+      const blob = new Blob([file as unknown as BlobPart]);
+      formData.append('file', blob, filename || 'file');
+    } else {
+      // Browser File/Blob or Node.js Blob/File
+      formData.append('file', file as unknown as Blob, filename);
+    }
+
+    return this.client.request<UploadResponse>('POST', '/api/storage/upload', {
+      body: formData,
+      isMultipart: true,
+    });
+  }
+
+  /**
+   * Delete a file from storage by its path
+   */
+  public async deleteFile(path: string): Promise<{ deleted: boolean }> {
+    return this.client.request<{ deleted: boolean }>('DELETE', '/api/storage/file', {
+      body: { path },
+    });
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,58 @@
+export interface UrBackendConfig {
+  apiKey: string;
+  baseUrl?: string;
+  headers?: Record<string, string>;
+}
+
+export interface RequestOptions {
+  body?: unknown;
+  token?: string;
+  isMultipart?: boolean;
+}
+
+export interface SignUpPayload {
+  email: string;
+  password: string;
+  name?: string;
+}
+
+export interface LoginPayload {
+  email: string;
+  password: string;
+}
+
+export interface AuthUser {
+  _id: string;
+  email: string;
+  name?: string;
+  [key: string]: unknown;
+}
+
+export interface AuthResponse {
+  token: string;
+  user: AuthUser;
+}
+
+export interface DocumentData {
+  _id: string;
+  [key: string]: unknown;
+}
+
+export interface InsertPayload {
+  [key: string]: unknown;
+}
+
+export interface UpdatePayload {
+  [key: string]: unknown;
+}
+
+export interface UploadResponse {
+  url: string;
+  path: string;
+}
+
+export interface ApiResponse<T> {
+  data: T;
+  success: boolean;
+  message?: string;
+}