@slyxup/core 1.0.2 → 1.2.0

package/src/errors.ts

@@ -1,41 +0,0 @@
-// SlyxUp Core SDK — typed errors
-
-export class SlyxupError extends Error {
-  readonly status: number;
-  readonly code: string;
-
-  constructor(message: string, status: number, code: string) {
-    super(message);
-    this.name = 'SlyxupError';
-    this.status = status;
-    this.code = code;
-  }
-}
-
-export class UnauthorizedError extends SlyxupError {
-  constructor(message = 'Unauthorized') {
-    super(message, 401, 'unauthorized');
-    this.name = 'UnauthorizedError';
-  }
-}
-
-export class ValidationError extends SlyxupError {
-  constructor(message = 'Validation failed') {
-    super(message, 400, 'validation_error');
-    this.name = 'ValidationError';
-  }
-}
-
-export class NetworkError extends SlyxupError {
-  constructor(message = 'Network request failed') {
-    super(message, 0, 'network_error');
-    this.name = 'NetworkError';
-  }
-}
-
-export class RateLimitError extends SlyxupError {
-  constructor(message = 'Too many requests') {
-    super(message, 429, 'rate_limited');
-    this.name = 'RateLimitError';
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export { SlyxupClient } from './client.js';
-export * from './types.js';
-export * from './errors.js';

package/src/types.ts

@@ -1,151 +0,0 @@
-// SlyxUp Core SDK — shared types
-
-export interface SlyxupUser {
-  id: string;
-  projectId: string | null;
-  email: string;
-  emailVerified: boolean;
-  username: string | null;
-  firstName: string | null;
-  lastName: string | null;
-  avatarUrl: string | null;
-  twoFactorEnabled: boolean;
-  preferences: Record<string, unknown> | null;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface SlyxupSession {
-  id: string;
-  userId: string;
-  expiresAt: string;
-}
-
-export interface SignInInput {
-  email?: string;
-  username?: string;
-  password: string;
-  projectId?: string;
-}
-
-export interface SignUpInput extends Omit<SignInInput, 'username'> {
-  firstName?: string;
-  lastName?: string;
-  username?: string;
-}
-
-export interface UpdateUserInput {
-  firstName?: string;
-  lastName?: string;
-  avatarUrl?: string;
-  username?: string | null;
-  preferences?: Record<string, unknown>;
-}
-
-export interface SessionResponse {
-  ok: true;
-  user: Pick<SlyxupUser, 'id' | 'email'>;
-  session: Pick<SlyxupSession, 'id' | 'expiresAt'>;
-}
-
-export interface ChangePasswordInput {
-  currentPassword: string;
-  newPassword: string;
-}
-
-export interface SlyxupSessionInfo {
-  id: string;
-  ipAddress: string | null;
-  userAgent: string | null;
-  expiresAt: string;
-  createdAt: string;
-  /** true when this session belongs to the caller's current cookie */
-  isCurrent: boolean;
-}
-
-export interface SessionsResponse {
-  ok: true;
-  sessions: SlyxupSessionInfo[];
-  total: number;
-  limit: number;
-  offset: number;
-}
-
-export interface RevokeSessionsResponse {
-  ok: true;
-  revoked: number;
-}
-
-export interface UserResponse {
-  ok: true;
-  user: SlyxupUser;
-}
-
-export interface AuthResponse {
-  ok: true;
-  user: Pick<SlyxupUser, 'id' | 'email'>;
-  sessionToken?: string;
-  expiresAt?: string;
-}
-
-/** Returned by signIn when the account has 2FA enabled. */
-export interface TwoFactorRequiredResponse {
-  ok: false;
-  code: '2FA_REQUIRED';
-  challengeToken: string;
-}
-
-/** Union returned by client.auth.signIn. */
-export type SignInResponse = AuthResponse | TwoFactorRequiredResponse;
-
-export interface TOTPSetupResponse {
-  ok: true;
-  secret: string;
-  provisioningUri: string;
-  accountName: string;
-}
-
-export interface EnableTOTPResponse {
-  ok: true;
-  recoveryCodes: string[];
-}
-
-export interface TwoFactorStatusResponse {
-  ok: boolean;
-  enabled: boolean;
-}
-
-export interface ConnectedAccount {
-  id: string;
-  provider: 'google' | 'github';
-  providerAccountId: string;
-  createdAt: string;
-}
-
-export interface ConnectedAccountsResponse {
-  ok: true;
-  accounts: ConnectedAccount[];
-}
-
-/** Input for completing a 2FA sign-in challenge. */
-export interface CompleteSignInInput {
-  challengeToken: string;
-  code?: string;
-  recoveryCode?: string;
-}
-
-export interface ErrorResponse {
-  ok: false;
-  error: string;
-}
-
-export type Result<T> = T | ErrorResponse;
-
-export interface SlyxupClientOptions {
-  /** Publishable key — pk_test_xxx / pk_live_xxx */
-  publishableKey?: string;
-  /** Secret key — sk_test_xxx / sk_live_xxx (server-side admin API) */
-  secretKey?: string;
-  /** API base URL, default https://auth.slyxup.online */
-  apiUrl?: string;
-}

package/test/client.test.ts

@@ -1,249 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { SlyxupClient } from '../src/client.js';
-import { SlyxupError, UnauthorizedError, NetworkError, RateLimitError } from '../src/errors.js';
-
-function mockFetch(
-  data: unknown,
-  init?: { ok?: boolean; status?: number; headers?: Record<string, string> }
-) {
-  const fn = vi.fn().mockResolvedValue({
-    ok: init?.ok ?? true,
-    status: init?.status ?? 200,
-    headers: {
-      get: (key: string) => {
-        const lower = key.toLowerCase();
-        for (const [k, v] of Object.entries(init?.headers ?? {})) {
-          if (k.toLowerCase() === lower) return v;
-        }
-        return null;
-      },
-    },
-    json: () => Promise.resolve(data),
-  });
-  global.fetch = fn;
-  return fn;
-}
-
-describe('SlyxupClient', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('constructor', () => {
-    it('should use default apiUrl', () => {
-      mockFetch({ ok: true });
-      const client = new SlyxupClient();
-      expect(client.apiUrl).toBe('https://auth.slyxup.online');
-    });
-
-    it('should strip trailing slash from apiUrl', () => {
-      mockFetch({ ok: true });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost:3000/' });
-      expect(client.apiUrl).toBe('http://localhost:3000');
-    });
-
-    it('should store publishableKey', () => {
-      mockFetch({ ok: true });
-      const client = new SlyxupClient({ publishableKey: 'pk_test_123' });
-      expect(client.publishableKey).toBe('pk_test_123');
-    });
-  });
-
-  describe('auth.signUp', () => {
-    it('should POST to /v1/auth/sign-up with JSON body', async () => {
-      const fn = mockFetch({ ok: true, user: { id: 'u1', email: 'a@b.com' } });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      const res = await client.auth.signUp({
-        email: 'a@b.com',
-        password: '12345678',
-        firstName: 'Test',
-      });
-      expect(fn).toHaveBeenCalledWith(
-        'http://localhost/v1/auth/sign-up',
-        expect.objectContaining({
-          method: 'POST',
-          body: JSON.stringify({ email: 'a@b.com', password: '12345678', firstName: 'Test' }),
-        })
-      );
-      expect(res).toEqual({ ok: true, user: { id: 'u1', email: 'a@b.com' } });
-    });
-
-    it('should throw SlyxupError when response has no user', async () => {
-      mockFetch({ ok: true, error: 'Invalid email' });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await expect(
-        client.auth.signUp({ email: 'bad', password: '12345678' })
-      ).rejects.toThrow(SlyxupError);
-    });
-  });
-
-  describe('auth.signIn', () => {
-    it('should POST to /v1/auth/sign-in', async () => {
-      const fn = mockFetch({ ok: true, user: { id: 'u1', email: 'a@b.com' } });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      const res = await client.auth.signIn({ email: 'a@b.com', password: 'pass' });
-      expect(fn).toHaveBeenCalledWith(
-        'http://localhost/v1/auth/sign-in',
-        expect.objectContaining({ method: 'POST' })
-      );
-      expect(res).toEqual({ ok: true, user: { id: 'u1', email: 'a@b.com' } });
-    });
-
-    it('should throw UnauthorizedError on 401', async () => {
-      mockFetch({ ok: false, error: 'Bad credentials' }, { ok: false, status: 401 });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await expect(
-        client.auth.signIn({ email: 'a@b.com', password: 'wrong' })
-      ).rejects.toThrow(UnauthorizedError);
-    });
-
-    it('should throw SlyxupError when response has no user', async () => {
-      mockFetch({ ok: true, error: 'No user' });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await expect(
-        client.auth.signIn({ email: 'a@b.com', password: 'pass' })
-      ).rejects.toThrow(SlyxupError);
-    });
-  });
-
-  describe('auth.signOut', () => {
-    it('should POST to /v1/auth/sign-out', async () => {
-      const fn = mockFetch({ ok: true });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      const res = await client.auth.signOut();
-      expect(fn).toHaveBeenCalledWith(
-        'http://localhost/v1/auth/sign-out',
-        expect.objectContaining({ method: 'POST' })
-      );
-      expect(res).toEqual({ ok: true });
-    });
-  });
-
-  describe('sessions.get', () => {
-    it('should GET /v1/session', async () => {
-      const data = { ok: true, user: { id: 'u1', email: 'a@b.com' }, session: { id: 's1', expiresAt: '2030' } };
-      const fn = mockFetch(data);
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      const res = await client.sessions.get();
-      expect(fn).toHaveBeenCalledWith('http://localhost/v1/session', expect.anything());
-      expect(res).toEqual(data);
-    });
-
-    it('should throw UnauthorizedError when no session in response', async () => {
-      mockFetch({ ok: true, error: 'No session' });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await expect(client.sessions.get()).rejects.toThrow(UnauthorizedError);
-    });
-
-    it('should throw NetworkError when fetch rejects', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new Error('fetch failed'));
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await expect(client.sessions.get()).rejects.toThrow(NetworkError);
-    });
-  });
-
-  describe('users.me', () => {
-    it('should GET /v1/user', async () => {
-      const user = { id: 'u1', email: 'a@b.com', firstName: 'Test', lastName: 'User', createdAt: '', updatedAt: '', projectId: null, emailVerified: true, avatarUrl: null, preferences: null };
-      const fn = mockFetch({ ok: true, user });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      const res = await client.users.me();
-      expect(fn).toHaveBeenCalledWith('http://localhost/v1/user', expect.anything());
-      expect(res.user).toEqual(user);
-    });
-
-    it('should throw UnauthorizedError when no user', async () => {
-      mockFetch({ ok: true, error: 'Not found' });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await expect(client.users.me()).rejects.toThrow(UnauthorizedError);
-    });
-  });
-
-  describe('users.update', () => {
-    it('should PATCH /v1/user with JSON body', async () => {
-      const fn = mockFetch({ ok: true, user: { id: 'u1', firstName: 'Jane' } });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await client.users.update({ firstName: 'Jane' });
-      expect(fn).toHaveBeenCalledWith(
-        'http://localhost/v1/user',
-        expect.objectContaining({ method: 'PATCH', body: JSON.stringify({ firstName: 'Jane' }) })
-      );
-    });
-  });
-
-  describe('users.delete', () => {
-    it('should DELETE /v1/user', async () => {
-      const fn = mockFetch({ ok: true });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      const res = await client.users.delete();
-      expect(fn).toHaveBeenCalledWith('http://localhost/v1/user', expect.objectContaining({ method: 'DELETE' }));
-      expect(res).toEqual({ ok: true });
-    });
-  });
-
-  describe('cookie jar', () => {
-    it('should capture Set-Cookie and forward as Cookie header', async () => {
-      const fn = vi.fn()
-        .mockResolvedValueOnce({
-          ok: true,
-          status: 200,
-          headers: {
-            get: (key: string) => key.toLowerCase() === 'set-cookie' ? 'slyxup_session=abc123; Path=/; HttpOnly' : null,
-          },
-          json: () => Promise.resolve({ ok: true, user: { id: 'u1', email: 'a@b.com' } }),
-        })
-        .mockResolvedValueOnce({
-          ok: true,
-          status: 200,
-          headers: { get: () => null },
-          json: () => Promise.resolve({ ok: true, user: { id: 'u1', email: 'a@b.com' }, session: { id: 's1', expiresAt: '2030' } }),
-        });
-      global.fetch = fn;
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await client.auth.signIn({ email: 'a@b.com', password: 'pass' });
-      await client.sessions.get();
-      expect(fn).toHaveBeenCalledTimes(2);
-      const secondCall = fn.mock.calls[1] as any[];
-      expect(secondCall[1].headers).toMatchObject({ Cookie: 'slyxup_session=abc123' });
-    });
-  });
-
-  describe('error handling', () => {
-    it('should throw RateLimitError on 429', async () => {
-      mockFetch({ error: 'rate limited' }, { ok: false, status: 429 });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await expect(client.sessions.get()).rejects.toThrow(RateLimitError);
-    });
-
-    it('should throw NetworkError when fetch rejects', async () => {
-      global.fetch = vi.fn().mockRejectedValue(new TypeError('Failed to fetch'));
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await expect(client.auth.signIn({ email: 'a', password: 'b' })).rejects.toThrow(NetworkError);
-    });
-
-    it('should throw SlyxupError on 500 with error message', async () => {
-      mockFetch({ error: 'Server error' }, { ok: false, status: 500 });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      try {
-        await client.sessions.get();
-        expect.fail('Should have thrown');
-      } catch (e) {
-        expect(e).toBeInstanceOf(SlyxupError);
-        expect((e as SlyxupError).status).toBe(500);
-        expect((e as SlyxupError).code).toBe('api_error');
-        expect((e as SlyxupError).message).toBe('Server error');
-      }
-    });
-
-    it('should handle invalid JSON gracefully', async () => {
-      global.fetch = vi.fn().mockResolvedValue({
-        ok: true,
-        status: 200,
-        headers: { get: () => null },
-        json: () => Promise.reject(new Error('not json')),
-      });
-      const client = new SlyxupClient({ apiUrl: 'http://localhost' });
-      await expect(client.sessions.get()).rejects.toThrow(UnauthorizedError);
-    });
-  });
-});

package/test/errors.test.ts

@@ -1,109 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  SlyxupError,
-  UnauthorizedError,
-  ValidationError,
-  NetworkError,
-  RateLimitError,
-} from '../src/errors.js';
-
-describe('SlyxupError', () => {
-  it('should set message, status, code, and name', () => {
-    const err = new SlyxupError('test', 500, 'test_error');
-    expect(err.message).toBe('test');
-    expect(err.status).toBe(500);
-    expect(err.code).toBe('test_error');
-    expect(err.name).toBe('SlyxupError');
-  });
-
-  it('should be instanceof Error', () => {
-    const err = new SlyxupError('test', 400, 'err');
-    expect(err).toBeInstanceOf(Error);
-  });
-
-  it('should be instanceof SlyxupError', () => {
-    const err = new SlyxupError('test', 400, 'err');
-    expect(err).toBeInstanceOf(SlyxupError);
-  });
-});
-
-describe('UnauthorizedError', () => {
-  it('should have default values', () => {
-    const err = new UnauthorizedError();
-    expect(err.message).toBe('Unauthorized');
-    expect(err.status).toBe(401);
-    expect(err.code).toBe('unauthorized');
-    expect(err.name).toBe('UnauthorizedError');
-  });
-
-  it('should accept custom message', () => {
-    const err = new UnauthorizedError('Custom');
-    expect(err.message).toBe('Custom');
-    expect(err.status).toBe(401);
-  });
-
-  it('should be instanceof SlyxupError', () => {
-    expect(new UnauthorizedError()).toBeInstanceOf(SlyxupError);
-    expect(new UnauthorizedError()).toBeInstanceOf(Error);
-  });
-});
-
-describe('ValidationError', () => {
-  it('should have default values', () => {
-    const err = new ValidationError();
-    expect(err.message).toBe('Validation failed');
-    expect(err.status).toBe(400);
-    expect(err.code).toBe('validation_error');
-    expect(err.name).toBe('ValidationError');
-  });
-
-  it('should accept custom message', () => {
-    const err = new ValidationError('Bad input');
-    expect(err.message).toBe('Bad input');
-    expect(err.status).toBe(400);
-  });
-
-  it('should be instanceof SlyxupError', () => {
-    expect(new ValidationError()).toBeInstanceOf(SlyxupError);
-  });
-});
-
-describe('NetworkError', () => {
-  it('should have default values', () => {
-    const err = new NetworkError();
-    expect(err.message).toBe('Network request failed');
-    expect(err.status).toBe(0);
-    expect(err.code).toBe('network_error');
-    expect(err.name).toBe('NetworkError');
-  });
-
-  it('should accept custom message', () => {
-    const err = new NetworkError('Timeout');
-    expect(err.message).toBe('Timeout');
-    expect(err.status).toBe(0);
-  });
-
-  it('should be instanceof SlyxupError', () => {
-    expect(new NetworkError()).toBeInstanceOf(SlyxupError);
-  });
-});
-
-describe('RateLimitError', () => {
-  it('should have default values', () => {
-    const err = new RateLimitError();
-    expect(err.message).toBe('Too many requests');
-    expect(err.status).toBe(429);
-    expect(err.code).toBe('rate_limited');
-    expect(err.name).toBe('RateLimitError');
-  });
-
-  it('should accept custom message', () => {
-    const err = new RateLimitError('Slow down');
-    expect(err.message).toBe('Slow down');
-    expect(err.status).toBe(429);
-  });
-
-  it('should be instanceof SlyxupError', () => {
-    expect(new RateLimitError()).toBeInstanceOf(SlyxupError);
-  });
-});

package/tsconfig.json

@@ -1 +0,0 @@
-{ "extends": "../../tsconfig.json", "compilerOptions": { "outDir": "dist", "rootDir": "src", "lib": ["ES2022", "DOM", "DOM.Iterable"] }, "include": ["src"] }

package/vitest.config.ts

@@ -1,2 +0,0 @@
-import { defineConfig } from 'vitest/config';
-export default defineConfig({ test: { globals: true, environment: 'node' } });