@slyxup/core 0.2.0 → 0.2.1

package/.turbo/turbo-build.log

@@ -0,0 +1,4 @@
+
+> @slyxup/core@0.2.1 build /home/runner/work/stack/stack/packages/core
+> tsc -p tsconfig.json
+

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @slyxup/core
 
+## 0.2.1
+
+### Patch Changes
+
+- [`2011599`](https://github.com/slyxup/stack/commit/2011599a9c989560e34bcea3147c18923e15962d) - CLI: new `slyxup auth` command group using @slyxup/core SDK — `auth signup`, `auth signin`, `auth verify` (email verification), `auth oauth` (opens Google/GitHub in browser). Browser open is non-blocking. CLI now depends on @slyxup/core.
+
 ## 0.2.0
 
 ### Minor Changes

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 SlyxUp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,14 +1,10 @@
 {
   "name": "@slyxup/core",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "@slyxup/core — SlyxUp SDK",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc --noEmit"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/slyxup/stack.git",
@@ -22,5 +18,13 @@
   "license": "MIT",
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "vitest": "^4.1.11"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --passWithNoTests"
   }
-}
+}

package/test/client.test.ts

@@ -0,0 +1,249 @@
+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

@@ -0,0 +1,109 @@
+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/vitest.config.ts

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