@urbackend/sdk 0.2.1 → 0.2.3

package/src/types/index.ts

@@ -1,154 +0,0 @@
-export interface UrBackendConfig {
-  apiKey: string;
-  baseUrl?: string;
-  headers?: Record<string, string>;
-}
-
-export interface RequestOptions {
-  body?: unknown;
-  token?: string;
-  isMultipart?: boolean;
-  credentials?: RequestCredentials;
-  headers?: Record<string, string>;
-}
-
-export interface QueryParams {
-  page?: number;
-  limit?: number;
-  sort?: string;
-  populate?: string | string[];
-  expand?: string | string[];
-  filter?: Record<string, unknown>;
-  [key: string]: unknown;
-}
-
-export interface SignUpPayload {
-  email: string;
-  password: string;
-  username?: string;
-  name?: string;
-  [key: string]: unknown;
-}
-
-export interface LoginPayload {
-  email: string;
-  password: string;
-}
-
-export interface UpdateProfilePayload {
-  username?: string;
-  name?: string;
-  [key: string]: unknown;
-}
-
-export interface ChangePasswordPayload {
-  currentPassword: string;
-  newPassword: string;
-}
-
-export interface VerifyEmailPayload {
-  email: string;
-  otp: string;
-}
-
-export interface ResendOtpPayload {
-  email: string;
-}
-
-export interface RequestPasswordResetPayload {
-  email: string;
-}
-
-export interface ResetPasswordPayload {
-  email: string;
-  otp: string;
-  newPassword: string;
-}
-
-export interface SocialExchangePayload {
-  token: string;
-  rtCode: string;
-}
-
-export interface SocialExchangeResponse {
-  refreshToken: string;
-}
-
-export interface AuthUser {
-  _id: string;
-  email: string;
-  username?: string;
-  name?: string;
-  [key: string]: unknown;
-}
-
-export interface AuthResponse {
-  accessToken?: string;
-  /** @deprecated use accessToken instead */
-  token?: string;
-  expiresIn?: string;
-  userId?: 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 PatchPayload {
-  [key: string]: unknown;
-}
-
-export interface SchemaField {
-  key: string;
-  type: string;
-  required: boolean;
-  unique?: boolean;
-  ref?: string;
-  items?: {
-    type: string;
-    fields?: SchemaField[];
-  };
-  fields?: SchemaField[];
-}
-
-export interface CollectionSchema {
-  name: string;
-  model: SchemaField[];
-}
-
-export interface SendMailPayload {
-  to: string | string[];
-  subject: string;
-  text?: string;
-  html?: string;
-}
-
-export interface SendMailResponse {
-  id: string | null;
-  provider: 'byok' | 'default';
-  monthlyUsage: number;
-  monthlyLimit: number;
-}
-
-export interface UploadResponse {
-  url: string;
-  path: string;
-  provider: 'internal' | 'external';
-  message?: string;
-}
-
-export interface ApiResponse<T> {
-  data: T;
-  success: boolean;
-  message?: string;
-}

package/tests/auth.test.ts

@@ -1,169 +0,0 @@
-import { expect, test, vi, beforeEach } from 'vitest';
-import urBackend from '../src/index';
-
-const mockApiKey = 'pk_live_test';
-let client: ReturnType<typeof urBackend>;
-
-beforeEach(() => {
-  vi.resetAllMocks();
-  client = urBackend({ apiKey: mockApiKey });
-});
-
-test('signUp returns user object on success', async () => {
-  const mockUser = { _id: '123', email: 'test@example.com' };
-  vi.stubGlobal(
-    'fetch',
-    vi.fn().mockResolvedValue({
-      ok: true,
-      headers: new Headers({ 'content-type': 'application/json' }),
-      json: () => Promise.resolve({ success: true, data: mockUser }),
-    }),
-  );
-
-  const user = await client.auth.signUp({ email: 'test@example.com', password: 'password' });
-  expect(user).toEqual(mockUser);
-});
-
-test('login stores accessToken', async () => {
-  const mockAccessToken = 'mock-access-token';
-  vi.stubGlobal(
-    'fetch',
-    vi.fn().mockResolvedValue({
-      ok: true,
-      headers: new Headers({ 'content-type': 'application/json' }),
-      json: () =>
-        Promise.resolve({
-          success: true,
-          data: { accessToken: mockAccessToken, user: { _id: '123', email: 'test@example.com' } },
-        }),
-    }),
-  );
-
-  const response = await client.auth.login({ email: 'test@example.com', password: 'password' });
-  expect(response.accessToken).toBe(mockAccessToken);
-  expect(client.auth.getToken()).toBe(mockAccessToken);
-});
-
-test('me() uses stored token from login', async () => {
-  const mockToken = 'mock-token';
-  const mockUser = { _id: '123', email: 'test@example.com' };
-
-  // First mock login
-  vi.stubGlobal(
-    'fetch',
-    vi.fn().mockResolvedValue({
-      ok: true,
-      headers: new Headers({ 'content-type': 'application/json' }),
-      json: () =>
-        Promise.resolve({
-          success: true,
-          data: { accessToken: mockToken, user: mockUser },
-        }),
-    }),
-  );
-  await client.auth.login({ email: 'test@example.com', password: 'password' });
-
-  // Then mock me call
-  const meFetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: mockUser }),
-  });
-  vi.stubGlobal('fetch', meFetchMock);
-
-  await client.auth.me();
-
-  expect(meFetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/userAuth/me'),
-    expect.objectContaining({
-      headers: expect.objectContaining({
-        Authorization: `Bearer ${mockToken}`,
-      }),
-    }),
-  );
-});
-
-test('logout() calls server and clears local token', async () => {
-  client.auth.setToken('test-token');
-  const logoutFetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, message: 'Logged out' }),
-  });
-  vi.stubGlobal('fetch', logoutFetchMock);
-
-  await client.auth.logout();
-
-  expect(logoutFetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/userAuth/logout'),
-    expect.objectContaining({
-      method: 'POST',
-      headers: expect.objectContaining({
-        Authorization: 'Bearer test-token',
-      }),
-    }),
-  );
-  expect(client.auth.getToken()).toBeUndefined();
-});
-
-test('refreshToken() uses credentials: include by default', async () => {
-  const refreshFetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: { accessToken: 'new-token' } }),
-  });
-  vi.stubGlobal('fetch', refreshFetchMock);
-
-  await client.auth.refreshToken();
-
-  expect(refreshFetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/userAuth/refresh-token'),
-    expect.objectContaining({
-      method: 'POST',
-      credentials: 'include',
-    }),
-  );
-});
-
-test('refreshToken(token) uses header mode', async () => {
-  const refreshFetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: { accessToken: 'new-token' } }),
-  });
-  vi.stubGlobal('fetch', refreshFetchMock);
-
-  await client.auth.refreshToken('manual-refresh-token');
-
-  expect(refreshFetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/userAuth/refresh-token'),
-    expect.objectContaining({
-      method: 'POST',
-      headers: expect.objectContaining({
-        'x-refresh-token': 'manual-refresh-token',
-        'x-refresh-token-mode': 'header',
-      }),
-    }),
-  );
-});
-
-test('socialStart returns correct URL', () => {
-  const url = client.auth.socialStart('github');
-  expect(url).toBe('https://api.ub.bitbros.in/api/userAuth/social/github/start?key=pk_live_test');
-});
-
-test('publicProfile calls correct endpoint', async () => {
-  const fetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: { username: 'yash' } }),
-  });
-  vi.stubGlobal('fetch', fetchMock);
-
-  await client.auth.publicProfile('yash');
-
-  expect(fetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/userAuth/public/yash'),
-    expect.any(Object),
-  );
-});

package/tests/database.test.ts

@@ -1,134 +0,0 @@
-import { expect, test, vi, beforeEach } from 'vitest';
-import urBackend from '../src/index';
-
-const mockApiKey = 'pk_live_test';
-const client = urBackend({ apiKey: mockApiKey });
-
-beforeEach(() => {
-  vi.resetAllMocks();
-});
-
-test('getAll returns array of typed documents', async () => {
-  const mockData = [
-    { _id: '1', name: 'Product 1' },
-    { _id: '2', name: 'Product 2' },
-  ];
-  vi.stubGlobal(
-    'fetch',
-    vi.fn().mockResolvedValue({
-      ok: true,
-      headers: new Headers({ 'content-type': 'application/json' }),
-      json: () => Promise.resolve({ success: true, data: mockData }),
-    }),
-  );
-
-  const items = await client.db.getAll<{ _id: string; name: string }>('products');
-  expect(items).toEqual(mockData);
-});
-
-test('getAll with query params builds correct query string', async () => {
-  const fetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: [] }),
-  });
-  vi.stubGlobal('fetch', fetchMock);
-
-  await client.db.getAll('products', {
-    page: 2,
-    limit: 10,
-    sort: 'price:asc',
-    populate: 'category',
-    filter: { price_gt: 100 }
-  });
-
-  const url = fetchMock.mock.calls[0][0] as string;
-  const searchParams = new URL(url).searchParams;
-  
-  expect(searchParams.get('page')).toBe('2');
-  expect(searchParams.get('limit')).toBe('10');
-  expect(searchParams.get('sort')).toBe('price:asc');
-  expect(searchParams.get('populate')).toBe('category');
-  expect(searchParams.get('price_gt')).toBe('100');
-});
-
-test('insert returns created document and handles optional token', async () => {
-  const payload = { name: 'New Item' };
-  const mockCreated = { _id: 'new-id', ...payload };
-  const fetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: mockCreated }),
-  });
-  vi.stubGlobal('fetch', fetchMock);
-
-  const result = await client.db.insert<{ _id: string; name: string }>('products', payload, 'user-token');
-  
-  expect(result._id).toBe('new-id');
-  expect(fetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/data/products'),
-    expect.objectContaining({
-      method: 'POST',
-      headers: expect.objectContaining({
-        Authorization: 'Bearer user-token',
-      }),
-    }),
-  );
-});
-
-test('patch sends PATCH request', async () => {
-  const payload = { price: 50 };
-  const mockUpdated = { _id: '1', name: 'Original', price: 50 };
-  const fetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: mockUpdated }),
-  });
-  vi.stubGlobal('fetch', fetchMock);
-
-  await client.db.patch('products', '1', payload);
-
-  expect(fetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/data/products/1'),
-    expect.objectContaining({
-      method: 'PATCH',
-      body: JSON.stringify(payload),
-    }),
-  );
-});
-
-test('getOne with populate builds correct query string', async () => {
-  const fetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: { _id: '1' } }),
-  });
-  vi.stubGlobal('fetch', fetchMock);
-
-  await client.db.getOne('products', '1', { populate: 'category' });
-
-  const url = fetchMock.mock.calls[0][0] as string;
-  expect(url).toContain('?populate=category');
-});
-
-test('delete returns { deleted: true } and handles token', async () => {
-  const fetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: { message: 'Document deleted', id: 'id-1' } }),
-  });
-  vi.stubGlobal('fetch', fetchMock);
-
-  const result = await client.db.delete('products', 'id-1', 'admin-token');
-  
-  expect(result.deleted).toBe(true);
-  expect(fetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/data/products/id-1'),
-    expect.objectContaining({
-      method: 'DELETE',
-      headers: expect.objectContaining({
-        Authorization: 'Bearer admin-token',
-      }),
-    }),
-  );
-});

package/tests/mail.test.ts

@@ -1,41 +0,0 @@
-import { expect, test, vi, beforeEach } from 'vitest';
-import urBackend from '../src/index';
-
-const mockApiKey = 'sk_live_test';
-const client = urBackend({ apiKey: mockApiKey });
-
-beforeEach(() => {
-  vi.resetAllMocks();
-});
-
-test('send() sends POST request to mail endpoint', async () => {
-  const payload = {
-    to: 'user@example.com',
-    subject: 'Hello',
-    text: 'Test mail'
-  };
-  
-  const mockResponse = {
-    success: true,
-    data: { id: 'msg_1', provider: 'default', monthlyUsage: 1, monthlyLimit: 100 },
-    message: 'Sent'
-  };
-
-  const fetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve(mockResponse),
-  });
-  vi.stubGlobal('fetch', fetchMock);
-
-  const result = await client.mail.send(payload);
-  
-  expect(result).toEqual(mockResponse.data);
-  expect(fetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/mail/send'),
-    expect.objectContaining({
-      method: 'POST',
-      body: JSON.stringify(payload),
-    }),
-  );
-});

package/tests/schema.test.ts

@@ -1,32 +0,0 @@
-import { expect, test, vi, beforeEach } from 'vitest';
-import urBackend from '../src/index';
-
-const mockApiKey = 'pk_live_test';
-const client = urBackend({ apiKey: mockApiKey });
-
-beforeEach(() => {
-  vi.resetAllMocks();
-});
-
-test('getSchema returns collection schema', async () => {
-  const mockSchema = {
-    name: 'products',
-    model: [
-      { key: 'name', type: 'String', required: true },
-      { key: 'price', type: 'Number', required: true }
-    ]
-  };
-  
-  vi.stubGlobal(
-    'fetch',
-    vi.fn().mockResolvedValue({
-      ok: true,
-      headers: new Headers({ 'content-type': 'application/json' }),
-      json: () => Promise.resolve({ message: 'Schema exists', collection: mockSchema }),
-    }),
-  );
-
-  const schema = await client.schema.getSchema('products');
-  expect(schema).toEqual(mockSchema);
-  expect(schema.name).toBe('products');
-});

package/tests/storage.test.ts

@@ -1,62 +0,0 @@
-/// <reference types="node" />
-import { expect, test, vi } from 'vitest';
-import urBackend from '../src/index';
-
-const mockApiKey = 'test-api-key';
-const client = urBackend({ apiKey: mockApiKey });
-
-test('upload sends FormData and returns { url, path }', async () => {
-  const mockResponse = { url: 'http://cdn.com/file.jpg', path: '/uploads/file.jpg' };
-  const fetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: mockResponse }),
-  });
-  vi.stubGlobal('fetch', fetchMock);
-
-  // In Node.js testing environment, use a Buffer as mock file
-  const result = await client.storage.upload(Buffer.from('mock binary data'), 'test.jpg');
-
-  expect(result).toEqual(mockResponse);
-  expect(fetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/storage/upload'),
-    expect.objectContaining({
-      method: 'POST',
-      body: expect.any(Object), // FormData
-    }),
-  );
-});
-
-test('deleteFile sends path in body', async () => {
-  const fetchMock = vi.fn().mockResolvedValue({
-    ok: true,
-    headers: new Headers({ 'content-type': 'application/json' }),
-    json: () => Promise.resolve({ success: true, data: { deleted: true } }),
-  });
-  vi.stubGlobal('fetch', fetchMock);
-
-  const result = await client.storage.deleteFile('/uploads/file.jpg');
-
-  expect(result.deleted).toBe(true);
-  expect(fetchMock).toHaveBeenCalledWith(
-    expect.stringContaining('/api/storage/file'),
-    expect.objectContaining({
-      method: 'DELETE',
-      body: JSON.stringify({ path: '/uploads/file.jpg' }),
-    }),
-  );
-});
-
-test('StorageError thrown on failure', async () => {
-  vi.stubGlobal(
-    'fetch',
-    vi.fn().mockResolvedValue({
-      ok: false,
-      status: 500,
-      url: 'https://api.urbackend.bitbros.in/api/storage/upload',
-      json: () => Promise.resolve({ success: false, message: 'Upload failed' }),
-    }),
-  );
-
-  await expect(client.storage.upload(Buffer.from('data'))).rejects.toThrow('Upload failed');
-});

package/tests/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../tsconfig.json",
-  "compilerOptions": {
-    "rootDir": "..",
-    "outDir": "../dist-test",
-    "types": ["node", "vitest/globals"]
-  },
-  "include": ["./**/*", "../src/**/*"]
-}

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["DOM", "DOM.Iterable", "ESNext"],
-    "types": ["node"],
-    "strict": true,
-    "declaration": true,
-    "outDir": "dist",
-    "rootDir": "src",
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "tests"]
-}

package/tsup.config.ts

@@ -1,16 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  format: ['cjs', 'esm'],
-  outExtension({ format }) {
-    return {
-      js: format === 'cjs' ? '.cjs' : '.mjs',
-    };
-  },
-  dts: true,
-  clean: true,
-  minify: false,
-  sourcemap: true,
-  target: 'es2020',
-});

package/vitest.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'json', 'html'],
-    },
-  },
-});