corebase-js 0.1.0

package/README.md

@@ -0,0 +1,69 @@
+# CoreBase JS Client
+
+A JavaScript/TypeScript client for CoreBase.
+
+## Installation
+
+```bash
+npm install corebase-js
+```
+
+## Initialization
+
+Initialize the client with your project URL and API Key.
+
+```javascript
+import { createClient } from 'corebase-js';
+
+const corebase = createClient('https://your-project-url.com', 'your-public-api-key');
+```
+
+## Authentication
+
+### Sign Up
+
+```javascript
+const { data, error } = await corebase.auth.signUp({
+  email: 'user@example.com',
+  password: 'password123',
+  name: 'John Doe'
+});
+
+if (error) {
+  console.error('Signup failed:', error.message);
+} else {
+  console.log('User created:', data.user);
+}
+```
+
+### Sign In
+
+```javascript
+const { data, error } = await corebase.auth.signIn({
+  email: 'user@example.com',
+  password: 'password123'
+});
+
+if (error) {
+  console.error('Login failed:', error.message);
+} else {
+  console.log('Logged in user:', data.user);
+  console.log('Access token:', data.access_token);
+}
+```
+
+### Get Current User
+
+```javascript
+const { data, error } = await corebase.auth.getUser();
+
+if (data) {
+  console.log('Current user:', data.user);
+}
+```
+
+### Sign Out
+
+```javascript
+await corebase.auth.signOut();
+```

package/dist/auth.d.ts

@@ -0,0 +1,38 @@
+import { AuthSession, ClientConfig, User } from './types';
+export interface AuthResponse<T> {
+    data: T | null;
+    error: {
+        message: string;
+        code?: string;
+        details?: string;
+    } | null;
+}
+export declare class AuthClient {
+    private config;
+    private session;
+    private storageKey;
+    constructor(config: ClientConfig);
+    private get baseUrl();
+    private get headers();
+    private request;
+    signUp(credentials: {
+        email: string;
+        password: string;
+        name?: string;
+    }): Promise<AuthResponse<{
+        user: User;
+    }>>;
+    signIn(credentials: {
+        email: string;
+        password: string;
+    }): Promise<AuthResponse<AuthSession>>;
+    getUser(): Promise<AuthResponse<{
+        user: User;
+    }>>;
+    signOut(): Promise<{
+        error: null;
+    }>;
+    getSession(): AuthSession | null;
+    private setSession;
+    private loadSession;
+}

package/dist/auth.js

@@ -0,0 +1,128 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthClient = void 0;
+class AuthClient {
+    constructor(config) {
+        this.session = null;
+        this.storageKey = 'corebase-auth-session';
+        this.config = config;
+        this.loadSession();
+    }
+    get baseUrl() {
+        return this.config.baseUrl || 'http://localhost:3000';
+    }
+    get headers() {
+        var _a;
+        const headers = {
+            'Content-Type': 'application/json',
+            'x-api-key': this.config.apiKey,
+        };
+        if ((_a = this.session) === null || _a === void 0 ? void 0 : _a.access_token) {
+            headers['Authorization'] = `Bearer ${this.session.access_token}`;
+        }
+        return headers;
+    }
+    request(path_1) {
+        return __awaiter(this, arguments, void 0, function* (path, options = {}) {
+            try {
+                const url = `${this.baseUrl}/v1${path}`;
+                const response = yield fetch(url, Object.assign(Object.assign({}, options), { headers: Object.assign(Object.assign({}, this.headers), options.headers) }));
+                const result = yield response.json();
+                if (!response.ok || result.status === 'error') {
+                    return {
+                        data: null,
+                        error: result.error || { message: `Request failed with status ${response.status}` },
+                    };
+                }
+                return { data: result.data, error: null };
+            }
+            catch (err) {
+                return { data: null, error: { message: err.message || 'Network request failed' } };
+            }
+        });
+    }
+    // --- Auth Methods ---
+    signUp(credentials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error } = yield this.request('/auth/project/signup', {
+                method: 'POST',
+                body: JSON.stringify(credentials),
+            });
+            if (error)
+                return { data: null, error };
+            if (!data)
+                return { data: null, error: { message: 'No data returned' } };
+            return {
+                data: {
+                    user: {
+                        id: data.id,
+                        email: data.email,
+                        name: data.name,
+                        role: data.role,
+                    },
+                },
+                error: null,
+            };
+        });
+    }
+    signIn(credentials) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { data, error } = yield this.request('/auth/project/login', {
+                method: 'POST',
+                body: JSON.stringify(credentials),
+            });
+            if (data) {
+                this.setSession(data);
+            }
+            return { data, error };
+        });
+    }
+    getUser() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.request('/auth/project/me', {
+                method: 'GET',
+            });
+        });
+    }
+    signOut() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this.session = null;
+            if (typeof localStorage !== 'undefined') {
+                localStorage.removeItem(this.storageKey);
+            }
+            return { error: null };
+        });
+    }
+    getSession() {
+        return this.session;
+    }
+    setSession(session) {
+        this.session = session;
+        if (typeof localStorage !== 'undefined') {
+            localStorage.setItem(this.storageKey, JSON.stringify(session));
+        }
+    }
+    loadSession() {
+        if (typeof localStorage !== 'undefined') {
+            const stored = localStorage.getItem(this.storageKey);
+            if (stored) {
+                try {
+                    this.session = JSON.parse(stored);
+                }
+                catch (e) {
+                    console.error('Failed to parse session', e);
+                }
+            }
+        }
+    }
+}
+exports.AuthClient = AuthClient;

package/dist/client.d.ts

@@ -0,0 +1,8 @@
+import { AuthClient } from './auth';
+import { ClientConfig } from './types';
+export declare class CoreBaseClient {
+    auth: AuthClient;
+    private config;
+    constructor(config: ClientConfig);
+}
+export declare function createClient(baseUrl: string, apiKey: string): CoreBaseClient;

package/dist/client.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CoreBaseClient = void 0;
+exports.createClient = createClient;
+const auth_1 = require("./auth");
+class CoreBaseClient {
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error('CoreBase: apiKey is required.');
+        }
+        if (!config.baseUrl) {
+            console.warn('CoreBase: baseUrl not provided, defaulting to http://localhost:3000');
+        }
+        this.config = config;
+        this.auth = new auth_1.AuthClient(config);
+    }
+}
+exports.CoreBaseClient = CoreBaseClient;
+function createClient(baseUrl, apiKey) {
+    return new CoreBaseClient({ baseUrl, apiKey });
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types';
+export * from './client';
+export * from './auth';

package/dist/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./client"), exports);
+__exportStar(require("./auth"), exports);

package/dist/types.d.ts

@@ -0,0 +1,25 @@
+export interface User {
+    id: string;
+    email: string;
+    name?: string;
+    role?: string;
+    created_at?: string;
+}
+export interface AuthSession {
+    access_token: string;
+    expires_in: number;
+    user: User;
+}
+export interface ApiResponse<T> {
+    status: 'success' | 'error';
+    data?: T;
+    error?: {
+        message: string;
+        code: string;
+        details?: string;
+    };
+}
+export interface ClientConfig {
+    apiKey: string;
+    baseUrl?: string;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "corebase-js",
+  "version": "0.1.0",
+  "description": "JavaScript client for CoreBase",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "baas",
+    "corebase",
+    "sdk"
+  ],
+  "author": "",
+  "license": "ISC",
+  "type": "commonjs",
+  "devDependencies": {
+    "typescript": "^5.0.0"
+  }
+}