spine-framework 0.1.61 → 1.0.0

package/src/types/index.ts

@@ -0,0 +1,163 @@
+export interface SpineConfig {
+  database: {
+    url: string
+    poolSize?: number
+  }
+  auth: {
+    providers: string[]
+    sessionTimeout: string
+  }
+  apps: {
+    registry: string
+    autoUpdate: boolean
+  }
+  ai?: {
+    provider: string
+    model: string
+  }
+}
+
+export interface SpineClient {
+  config: SpineConfig
+  supabase: any
+  auth: AuthClient
+  apps: AppsClient
+}
+
+export interface AuthClient {
+  signIn: (credentials: SignInCredentials) => Promise<AuthResult>
+  signUp: (credentials: SignUpCredentials) => Promise<AuthResult>
+  signOut: () => Promise<void>
+  getCurrentUser: () => Promise<User | null>
+  onAuthStateChange: (callback: (user: User | null) => void) => () => void
+}
+
+export interface AppsClient {
+  list: (filters?: AppFilters) => Promise<App[]>
+  install: (appSlug: string, options?: InstallOptions) => Promise<void>
+  uninstall: (appSlug: string) => Promise<void>
+  update: (appSlug: string) => Promise<void>
+}
+
+export interface User {
+  id: string
+  email: string
+  name?: string
+  avatar_url?: string
+  role?: string
+  account_id: string
+  created_at: string
+  updated_at: string
+}
+
+export interface Account {
+  id: string
+  name: string
+  slug: string
+  type: 'tenant' | 'organization' | 'individual'
+  owner_account_id?: string
+  is_active: boolean
+  created_at: string
+  updated_at: string
+}
+
+export interface App {
+  id: string
+  slug: string
+  name: string
+  description: string
+  version: string
+  app_type: string
+  source: string
+  owner_account_id?: string
+  is_active: boolean
+  is_system: boolean
+  min_role?: string
+  config: Record<string, any>
+  nav_items: NavItem[]
+  route_prefix?: string
+  renderer: string
+  created_at: string
+}
+
+export interface NavItem {
+  title: string
+  path: string
+  icon: string
+  order: number
+  children?: NavItem[]
+}
+
+export interface SignInCredentials {
+  email: string
+  password: string
+}
+
+export interface SignUpCredentials {
+  email: string
+  password: string
+  name?: string
+}
+
+export interface AuthResult {
+  user: User
+  session: any
+}
+
+export interface AppFilters {
+  account_id?: string
+  include_system?: boolean
+  include_inactive?: boolean
+  app_type?: string
+}
+
+export interface InstallOptions {
+  account_id?: string
+  config?: Record<string, any>
+}
+
+export interface Permission {
+  action: string
+  resource: string
+  conditions?: Record<string, any>
+}
+
+export interface Role {
+  id: string
+  slug: string
+  name: string
+  description: string
+  permissions: Permission[]
+}
+
+export interface Item {
+  id: string
+  type_id: string
+  account_id: string
+  title: string
+  content: any
+  status: string
+  created_at: string
+  updated_at: string
+}
+
+export interface Thread {
+  id: string
+  target_type: string
+  target_id: string
+  title: string
+  visibility: string
+  status: string
+  created_at: string
+  updated_at: string
+}
+
+export interface Message {
+  id: string
+  thread_id: string
+  direction: 'in' | 'out'
+  content: any
+  sequence: number
+  visibility: string
+  created_at: string
+}

package/src/utils/api.ts

@@ -0,0 +1,88 @@
+interface ApiFetchOptions {
+  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH'
+  headers?: Record<string, string>
+  body?: any
+  signal?: AbortSignal
+}
+
+interface ApiResponse<T = any> {
+  data: T | null
+  error: string | null
+  meta?: {
+    requestId: string
+    duration: number
+  }
+}
+
+export async function apiFetch<T = any>(
+  path: string,
+  options: ApiFetchOptions = {}
+): Promise<ApiResponse<T>> {
+  const startTime = Date.now()
+  const requestId = `req-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`
+
+  const defaultHeaders: Record<string, string> = {
+    'Content-Type': 'application/json',
+    'X-Request-ID': requestId
+  }
+
+  const headers = { ...defaultHeaders, ...options.headers }
+
+  try {
+    const response = await fetch(path, {
+      method: options.method || 'GET',
+      headers,
+      body: options.body ? JSON.stringify(options.body) : undefined,
+      signal: options.signal
+    })
+
+    const duration = Date.now() - startTime
+
+    if (!response.ok) {
+      const errorText = await response.text()
+      return {
+        data: null,
+        error: `HTTP ${response.status}: ${errorText}`,
+        meta: { requestId, duration }
+      }
+    }
+
+    const contentType = response.headers.get('content-type')
+    let data: T | null = null
+
+    if (contentType?.includes('application/json')) {
+      data = await response.json()
+    } else if (contentType?.includes('text/')) {
+      data = (await response.text()) as unknown as T
+    } else {
+      data = (await response.blob()) as unknown as T
+    }
+
+    return {
+      data,
+      error: null,
+      meta: { requestId, duration }
+    }
+  } catch (error) {
+    const duration = Date.now() - startTime
+    const errorMessage = error instanceof Error ? error.message : 'Unknown error'
+
+    return {
+      data: null,
+      error: errorMessage,
+      meta: { requestId, duration }
+    }
+  }
+}
+
+export function createApiError(message: string, code?: string): Error {
+  const error = new Error(message)
+  if (code) {
+    (error as any).code = code
+  }
+  return error
+}
+
+export function isApiError(error: any): error is Error & { code?: string } {
+  return error instanceof Error && 'code' in error
+}

package/src/utils/client.ts

@@ -0,0 +1,146 @@
+import { createClient } from '@supabase/supabase-js'
+import { SpineClient, SpineConfig, AuthClient, AppsClient } from '../types'
+
+export function createSpineClient(config: SpineConfig): SpineClient {
+  const supabase = createClient(config.database.url, config.database.url.replace('/rest/v1', '/auth/v1'))
+
+  const authClient: AuthClient = {
+    signIn: async (credentials) => {
+      const { data, error } = await supabase.auth.signInWithPassword({
+        email: credentials.email,
+        password: credentials.password
+      })
+      
+      if (error) throw error
+      
+      return {
+        user: {
+          id: data.user!.id,
+          email: data.user!.email!,
+          name: data.user!.user_metadata?.name,
+          avatar_url: data.user!.user_metadata?.avatar_url,
+          role: data.user!.user_metadata?.role,
+          account_id: data.user!.user_metadata?.account_id || data.user!.id,
+          created_at: data.user!.created_at,
+          updated_at: data.user!.updated_at || data.user!.created_at
+        },
+        session: data.session
+      }
+    },
+    
+    signUp: async (credentials) => {
+      const { data, error } = await supabase.auth.signUp({
+        email: credentials.email,
+        password: credentials.password,
+        options: {
+          data: {
+            name: credentials.name
+          }
+        }
+      })
+      
+      if (error) throw error
+      
+      return {
+        user: {
+          id: data.user!.id,
+          email: data.user!.email!,
+          name: data.user!.user_metadata?.name,
+          avatar_url: data.user!.user_metadata?.avatar_url,
+          role: data.user!.user_metadata?.role,
+          account_id: data.user!.user_metadata?.account_id || data.user!.id,
+          created_at: data.user!.created_at,
+          updated_at: data.user!.updated_at || data.user!.created_at
+        },
+        session: data.session
+      }
+    },
+    
+    signOut: async () => {
+      const { error } = await supabase.auth.signOut()
+      if (error) throw error
+    },
+    
+    getCurrentUser: async () => {
+      const { data: { user } } = await supabase.auth.getUser()
+      
+      if (!user) return null
+      
+      return {
+        id: user.id,
+        email: user.email!,
+        name: user.user_metadata?.name,
+        avatar_url: user.user_metadata?.avatar_url,
+        role: user.user_metadata?.role,
+        account_id: user.user_metadata?.account_id || user.id,
+        created_at: user.created_at,
+        updated_at: user.updated_at || user.created_at
+      }
+    },
+    
+    onAuthStateChange: (callback) => {
+      const { data: { subscription } } = supabase.auth.onAuthStateChange((_event, session) => {
+        const user = session?.user ? {
+          id: session.user.id,
+          email: session.user.email!,
+          name: session.user.user_metadata?.name,
+          avatar_url: session.user.user_metadata?.avatar_url,
+          role: session.user.user_metadata?.role,
+          account_id: session.user.user_metadata?.account_id || session.user.id,
+          created_at: session.user.created_at,
+          updated_at: session.user.updated_at || session.user.created_at
+        } : null
+        
+        callback(user)
+      })
+      
+      return () => subscription.unsubscribe()
+    }
+  }
+
+  const appsClient: AppsClient = {
+    list: async (filters) => {
+      const { data, error } = await supabase.rpc('get_account_apps', {
+        account_id: filters?.account_id,
+        include_system: filters?.include_system !== false,
+        include_inactive: filters?.include_inactive === true
+      })
+      
+      if (error) throw error
+      return data || []
+    },
+    
+    install: async (appSlug, options) => {
+      const { error } = await supabase.rpc('install_app', {
+        app_slug: appSlug,
+        account_id: options?.account_id,
+        config: options?.config || {}
+      })
+      
+      if (error) throw error
+    },
+    
+    uninstall: async (appSlug) => {
+      const { error } = await supabase.rpc('uninstall_app', {
+        app_slug: appSlug
+      })
+      
+      if (error) throw error
+    },
+    
+    update: async (appSlug) => {
+      const { error } = await supabase.rpc('update_app', {
+        app_slug: appSlug
+      })
+      
+      if (error) throw error
+    }
+  }
+
+  return {
+    config,
+    supabase,
+    auth: authClient,
+    apps: appsClient
+  }
+}

package/src/utils/config.ts

@@ -0,0 +1,20 @@
+import { SpineConfig } from '../types'
+
+let globalConfig: SpineConfig | null = null
+
+export function configureSpine(config: SpineConfig): void {
+  globalConfig = config
+}
+
+export function getSpineConfig(): SpineConfig | null {
+  return globalConfig
+}
+
+export function mergeConfig(base: SpineConfig, override: Partial<SpineConfig>): SpineConfig {
+  return {
+    database: { ...base.database, ...override.database },
+    auth: { ...base.auth, ...override.auth },
+    apps: { ...base.apps, ...override.apps },
+    ai: base.ai && override.ai ? { ...base.ai, ...override.ai } : base.ai || override.ai
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export { createSpineClient } from './client'
+export { configureSpine } from './config'
+export { apiFetch } from './api'

package/.framework/README.md

@@ -1,129 +0,0 @@
-# Spine v2 Frontend
-
-This is the frontend shell for Spine v2, built with React, TypeScript, and Tailwind CSS.
-
-## Getting Started
-
-### Prerequisites
-
-- Node.js 18+ 
-- npm or yarn
-- Supabase project
-
-### Installation
-
-1. Copy the environment file:
-```bash
-cp .env.example .env.local
-```
-
-2. Configure your Supabase credentials in `.env.local`:
-```env
-VITE_SUPABASE_URL=your_supabase_url
-VITE_SUPABASE_ANON_KEY=your_supabase_anon_key
-```
-
-3. Install dependencies:
-```bash
-npm install
-```
-
-### Development
-
-Start the development server:
-```bash
-npm run dev
-```
-
-The application will be available at `http://localhost:3001`.
-
-### Build
-
-Build for production:
-```bash
-npm run build
-```
-
-### Functions
-
-Start the Netlify functions server:
-```bash
-npm run functions:dev
-```
-
-## Project Structure
-
-```
-src/
-├── components/
-│   ├── layout/          # Layout components (Header, Sidebar, etc.)
-│   └── ui/              # Reusable UI components
-├── contexts/            # React contexts (Auth, etc.)
-├── lib/                 # Utility functions and configurations
-├── pages/               # Page components
-│   ├── auth/           # Authentication pages
-│   └── admin/          # Admin pages
-├── types/               # TypeScript type definitions
-├── App.tsx             # Main app component
-├── main.tsx            # App entry point
-└── index.css           # Global styles
-```
-
-## Features
-
-- **Authentication**: Secure login/logout with Supabase
-- **Layout**: Responsive sidebar navigation and header
-- **Admin Interface**: Full admin pages for managing accounts, people, types, and apps
-- **Item Management**: Generic item viewing and management
-- **Dashboard**: Overview with statistics and recent activity
-- **Type Safety**: Full TypeScript support throughout
-
-## Key Components
-
-### Authentication
-- Uses Supabase Auth for secure authentication
-- JWT token management with automatic refresh
-- Role-based access control
-
-### Layout System
-- Responsive sidebar navigation
-- Mobile-friendly with collapsible menu
-- User profile and logout functionality
-
-### Admin Pages
-- **Accounts**: Multi-tenant account management
-- **People**: User management across accounts
-- **Types**: Item type schema management
-- **Apps**: Application configuration and management
-
-### Styling
-- Tailwind CSS for utility-first styling
-- Custom CSS variables for theming
-- Component-based styling approach
-
-## Environment Variables
-
-| Variable | Description | Required |
-|----------|-------------|----------|
-| `VITE_SUPABASE_URL` | Supabase project URL | Yes |
-| `VITE_SUPABASE_ANON_KEY` | Supabase anonymous key | Yes |
-| `VITE_NETLIFY_FUNCTIONS_URL` | Netlify functions URL | No |
-
-## Scripts
-
-- `npm run dev` - Start development server
-- `npm run build` - Build for production
-- `npm run preview` - Preview production build
-- `npm run functions:dev` - Start functions server
-
-## Contributing
-
-1. Follow the existing code style
-2. Use TypeScript for all new code
-3. Add proper error handling
-4. Include loading states where appropriate
-5. Test responsive design
-
-## License
-
-This project is part of the Spine v2 framework.

package/.framework/cli/bin.cjs

@@ -1,14 +0,0 @@
-#!/usr/bin/env node
-// Thin shebang wrapper — invokes the TypeScript CLI via tsx.
-// This file is the npm bin entry point for spine-framework.
-const { execFileSync } = require('child_process')
-const { resolve } = require('path')
-
-const tsx = resolve(__dirname, '../../node_modules/.bin/tsx')
-const entry = resolve(__dirname, 'index.ts')
-
-try {
-  execFileSync(tsx, [entry, ...process.argv.slice(2)], { stdio: 'inherit' })
-} catch (e) {
-  process.exit(e.status ?? 1)
-}