@owlmeans/web-db 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 OwlMeans Common — Fullstack typescript framework
+
+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/README.md

@@ -0,0 +1,784 @@
+# @owlmeans/web-db
+
+Web database implementation for OwlMeans Common applications. This package provides a robust client-side database service built on IndexedDB through the `idb-keyval` library, offering persistent storage for web applications with a simple key-value interface.
+
+## Overview
+
+The `@owlmeans/web-db` package implements the `ClientDbService` interface from `@owlmeans/client-resource`, providing web-specific database functionality. It offers:
+
+- **IndexedDB Integration**: Leverages browser's IndexedDB for persistent storage
+- **Simple Key-Value API**: Clean, promise-based interface for data operations
+- **Multiple Database Support**: Manage multiple isolated database instances
+- **Automatic Namespacing**: Prevents key collisions between different resources
+- **Service Integration**: Seamless integration with OwlMeans context system
+- **Data Persistence**: Survives browser sessions and page reloads
+- **Cross-Tab Synchronization**: Data changes are visible across browser tabs
+
+This package is part of the OwlMeans database implementation family:
+- **@owlmeans/client-resource**: Client resource management interfaces
+- **@owlmeans/web-db**: Web IndexedDB implementation *(this package)*
+- **@owlmeans/native-db**: React Native database implementation
+
+## Installation
+
+```bash
+npm install @owlmeans/web-db
+```
+
+## Core Concepts
+
+### IndexedDB Foundation
+Built on IndexedDB, the standard web database API, providing reliable persistent storage that works offline and survives browser restarts.
+
+### Namespaced Storage
+Each database instance uses a namespace prefix to prevent key collisions, allowing multiple resources to share the same underlying storage safely.
+
+### Service Architecture
+Implements the ClientDbService interface, making it compatible with the OwlMeans resource system and context management.
+
+## API Reference
+
+### Factory Functions
+
+#### `makeWebDbService(alias?: string): WebDbService`
+
+Creates a web database service instance that manages IndexedDB storage.
+
+```typescript
+import { makeWebDbService } from '@owlmeans/web-db'
+
+const dbService = makeWebDbService('main-db')
+```
+
+**Parameters:**
+- `alias`: string (optional) - Service alias for registration, defaults to 'client-db'
+
+**Returns:** WebDbService instance ready for registration with context
+
+#### `appendWebDbService<C, T>(context: T, alias?: string): T`
+
+Appends a web database service to the application context.
+
+```typescript
+import { appendWebDbService } from '@owlmeans/web-db'
+import { makeClientContext } from '@owlmeans/client-context'
+
+const context = makeClientContext(config)
+appendWebDbService(context)
+
+// Access the service
+const dbService = context.service<WebDbService>('client-db')
+```
+
+**Parameters:**
+- `context`: T - The client context to append the service to
+- `alias`: string (optional) - Service alias, defaults to 'client-db'
+
+**Returns:** Enhanced context with the registered database service
+
+### Core Interfaces
+
+#### `WebDbService`
+
+Main database service interface that extends both InitializedService and ClientDbService.
+
+```typescript
+interface WebDbService extends InitializedService, ClientDbService {
+  // Inherited from ClientDbService:
+  initialize(alias?: string): Promise<ClientDb>    // Create database instance
+  erase(): Promise<void>                          // Clear all data
+  
+  // Inherited from InitializedService:
+  initialized: boolean                            // Initialization status
+  init?(): Promise<void>                         // Initialization method
+}
+```
+
+#### `ClientDb`
+
+Database instance interface providing key-value operations.
+
+```typescript
+interface ClientDb {
+  get<T>(id: string): Promise<T>                  // Retrieve value by key
+  set<T>(id: string, value: T): Promise<void>     // Store value by key
+  has(id: string): Promise<boolean>               // Check if key exists
+  del(id: string): Promise<boolean>               // Delete key and return success
+}
+```
+
+### Database Methods Detailed Reference
+
+#### `initialize(alias?: string): Promise<ClientDb>`
+
+**Purpose**: Creates and returns a database instance with the specified namespace
+
+**Behavior**:
+- Creates a new ClientDb instance if one doesn't exist for the alias
+- Returns existing instance if already created for the alias
+- Automatically namespaces all keys with the alias prefix
+- Uses IndexedDB through idb-keyval for persistent storage
+
+**Usage**: Called by resources to get their database instance
+
+**Parameters**:
+- `alias`: string (optional) - Namespace for the database instance
+
+**Returns**: Promise that resolves to ClientDb instance
+
+```typescript
+const dbService = context.service<WebDbService>('client-db')
+
+// Create database for users
+const userDb = await dbService.initialize('users')
+
+// Create database for settings
+const settingsDb = await dbService.initialize('settings')
+
+// Each database is isolated from others
+await userDb.set('john', { name: 'John Doe' })
+await settingsDb.set('theme', 'dark')
+```
+
+#### `erase(): Promise<void>`
+
+**Purpose**: Completely clears all data from IndexedDB
+
+**Behavior**: 
+- Removes all data across all database instances
+- Irreversible operation that clears entire IndexedDB store
+- Affects all namespaces and aliases
+
+**Usage**: Data cleanup, reset operations, testing
+
+**Warning**: This removes ALL data stored by the application
+
+```typescript
+const dbService = context.service<WebDbService>('client-db')
+
+// WARNING: This clears ALL application data
+await dbService.erase()
+console.log('All database data has been erased')
+```
+
+### ClientDb Instance Methods
+
+#### `get<T>(id: string): Promise<T>`
+
+**Purpose**: Retrieves a value from storage by its key
+
+**Behavior**:
+- Returns the stored value if key exists
+- Returns undefined if key doesn't exist
+- Automatically deserializes complex objects
+- Type-safe with TypeScript generics
+
+**Usage**: Loading stored data
+
+```typescript
+const userDb = await dbService.initialize('users')
+
+// Get user data
+const user = await userDb.get<UserData>('john')
+if (user) {
+  console.log('User found:', user.name)
+} else {
+  console.log('User not found')
+}
+```
+
+#### `set<T>(id: string, value: T): Promise<void>`
+
+**Purpose**: Stores a value in the database with the specified key
+
+**Behavior**:
+- Stores any serializable JavaScript value
+- Overwrites existing value if key already exists
+- Automatically serializes complex objects
+- Type-safe with TypeScript generics
+
+**Usage**: Saving data to persistent storage
+
+```typescript
+const userDb = await dbService.initialize('users')
+
+// Store user data
+await userDb.set('john', {
+  name: 'John Doe',
+  email: 'john@example.com',
+  preferences: { theme: 'dark' }
+})
+
+// Store simple values
+await userDb.set('last-login', new Date())
+await userDb.set('session-count', 42)
+```
+
+#### `has(id: string): Promise<boolean>`
+
+**Purpose**: Checks if a key exists in the database
+
+**Behavior**:
+- Returns true if key exists (even if value is null/undefined)
+- Returns false if key doesn't exist
+- Efficient check without retrieving the full value
+
+**Usage**: Existence checks before operations
+
+```typescript
+const userDb = await dbService.initialize('users')
+
+// Check if user exists before loading
+const userExists = await userDb.has('john')
+if (userExists) {
+  const user = await userDb.get('john')
+  console.log('Loading existing user:', user.name)
+} else {
+  console.log('User not found, creating new user')
+}
+```
+
+#### `del(id: string): Promise<boolean>`
+
+**Purpose**: Deletes a key from the database
+
+**Behavior**:
+- Removes the key and its value from storage
+- Returns true if key existed and was deleted
+- Returns false if key didn't exist
+- Atomic operation
+
+**Usage**: Removing data from storage
+
+```typescript
+const userDb = await dbService.initialize('users')
+
+// Delete user data
+const wasDeleted = await userDb.del('john')
+if (wasDeleted) {
+  console.log('User john was deleted')
+} else {
+  console.log('User john was not found')
+}
+
+// Verify deletion
+const stillExists = await userDb.has('john')
+console.log('User still exists:', stillExists) // false
+```
+
+### Constants
+
+#### `DEFAULT_ALIAS`
+Default service alias (`'client-db'`) imported from `@owlmeans/client-resource`.
+
+## Usage Examples
+
+### Basic Database Setup
+
+```typescript
+import { appendWebDbService } from '@owlmeans/web-db'
+import { makeClientContext } from '@owlmeans/client-context'
+
+// Create context with database service
+const context = makeClientContext(config)
+appendWebDbService(context)
+
+// Initialize context
+await context.configure().init()
+
+// Access database service
+const dbService = context.service<WebDbService>('client-db')
+console.log('Database service ready:', dbService.initialized)
+```
+
+### Multiple Database Instances
+
+```typescript
+const dbService = context.service<WebDbService>('client-db')
+
+// Create separate databases for different purposes
+const userDb = await dbService.initialize('users')
+const settingsDb = await dbService.initialize('settings')
+const cacheDb = await dbService.initialize('cache')
+
+// Each database is completely isolated
+await userDb.set('current-user', { id: '123', name: 'John' })
+await settingsDb.set('theme', 'dark')
+await cacheDb.set('api-response', { data: [...], timestamp: Date.now() })
+
+// No interference between databases
+const userTheme = await userDb.get('theme') // undefined
+const settingsTheme = await settingsDb.get('theme') // 'dark'
+```
+
+### User Data Management
+
+```typescript
+interface UserProfile {
+  id: string
+  name: string
+  email: string
+  preferences: {
+    theme: 'light' | 'dark'
+    language: string
+    notifications: boolean
+  }
+  lastLogin: Date
+}
+
+const dbService = context.service<WebDbService>('client-db')
+const userDb = await dbService.initialize('user-profiles')
+
+// Save user profile
+const saveUserProfile = async (profile: UserProfile) => {
+  await userDb.set(profile.id, profile)
+  console.log('Profile saved for:', profile.name)
+}
+
+// Load user profile
+const loadUserProfile = async (userId: string): Promise<UserProfile | null> => {
+  const hasProfile = await userDb.has(userId)
+  if (!hasProfile) {
+    return null
+  }
+  
+  return await userDb.get<UserProfile>(userId)
+}
+
+// Update last login
+const updateLastLogin = async (userId: string) => {
+  const profile = await loadUserProfile(userId)
+  if (profile) {
+    profile.lastLogin = new Date()
+    await saveUserProfile(profile)
+  }
+}
+
+// Usage
+await saveUserProfile({
+  id: 'user-123',
+  name: 'Alice Johnson',
+  email: 'alice@example.com',
+  preferences: {
+    theme: 'dark',
+    language: 'en',
+    notifications: true
+  },
+  lastLogin: new Date()
+})
+
+const profile = await loadUserProfile('user-123')
+console.log('Loaded profile:', profile?.name)
+```
+
+### Settings Persistence
+
+```typescript
+interface AppSettings {
+  theme: 'light' | 'dark' | 'auto'
+  language: string
+  autoSave: boolean
+  apiEndpoint: string
+  debugMode: boolean
+}
+
+const dbService = context.service<WebDbService>('client-db')
+const settingsDb = await dbService.initialize('app-settings')
+
+class SettingsManager {
+  private static readonly SETTINGS_KEY = 'app-settings'
+  
+  static async load(): Promise<AppSettings> {
+    const hasSettings = await settingsDb.has(this.SETTINGS_KEY)
+    if (!hasSettings) {
+      return this.getDefaultSettings()
+    }
+    
+    const saved = await settingsDb.get<AppSettings>(this.SETTINGS_KEY)
+    return { ...this.getDefaultSettings(), ...saved }
+  }
+  
+  static async save(settings: Partial<AppSettings>): Promise<void> {
+    const current = await this.load()
+    const updated = { ...current, ...settings }
+    await settingsDb.set(this.SETTINGS_KEY, updated)
+  }
+  
+  static async reset(): Promise<void> {
+    await settingsDb.del(this.SETTINGS_KEY)
+  }
+  
+  private static getDefaultSettings(): AppSettings {
+    return {
+      theme: 'auto',
+      language: 'en',
+      autoSave: true,
+      apiEndpoint: '/api',
+      debugMode: false
+    }
+  }
+}
+
+// Usage
+const settings = await SettingsManager.load()
+console.log('Current theme:', settings.theme)
+
+await SettingsManager.save({ theme: 'dark', debugMode: true })
+console.log('Settings updated')
+```
+
+### Caching System
+
+```typescript
+interface CacheEntry<T> {
+  data: T
+  timestamp: number
+  ttl: number // time to live in milliseconds
+}
+
+class WebCache {
+  private db: ClientDb
+  
+  constructor(private dbService: WebDbService) {}
+  
+  async initialize() {
+    this.db = await this.dbService.initialize('cache')
+  }
+  
+  async set<T>(key: string, data: T, ttlMs: number = 300000): Promise<void> {
+    const entry: CacheEntry<T> = {
+      data,
+      timestamp: Date.now(),
+      ttl: ttlMs
+    }
+    await this.db.set(key, entry)
+  }
+  
+  async get<T>(key: string): Promise<T | null> {
+    const hasKey = await this.db.has(key)
+    if (!hasKey) {
+      return null
+    }
+    
+    const entry = await this.db.get<CacheEntry<T>>(key)
+    if (!entry) {
+      return null
+    }
+    
+    // Check if expired
+    if (Date.now() - entry.timestamp > entry.ttl) {
+      await this.db.del(key)
+      return null
+    }
+    
+    return entry.data
+  }
+  
+  async clear(): Promise<void> {
+    // Note: This is a simplified version
+    // In practice, you'd need to track cache keys
+    console.log('Cache clear not implemented - use dbService.erase() for full clear')
+  }
+}
+
+// Usage
+const dbService = context.service<WebDbService>('client-db')
+const cache = new WebCache(dbService)
+await cache.initialize()
+
+// Cache API response for 5 minutes
+await cache.set('user-list', userData, 5 * 60 * 1000)
+
+// Try to get from cache
+const cachedUsers = await cache.get('user-list')
+if (cachedUsers) {
+  console.log('Using cached data:', cachedUsers)
+} else {
+  console.log('Cache miss, fetching fresh data')
+}
+```
+
+### Data Migration
+
+```typescript
+class DataMigration {
+  private dbService: WebDbService
+  
+  constructor(dbService: WebDbService) {
+    this.dbService = dbService
+  }
+  
+  async migrateUserData() {
+    const userDb = await this.dbService.initialize('users')
+    const migrationDb = await this.dbService.initialize('migration')
+    
+    // Check if migration already done
+    const migrationDone = await migrationDb.has('user-data-v2')
+    if (migrationDone) {
+      console.log('Migration already completed')
+      return
+    }
+    
+    // Simulate migration from old format to new format
+    const oldUserData = await userDb.get('old-format-user')
+    if (oldUserData) {
+      const newUserData = this.transformUserData(oldUserData)
+      await userDb.set('new-format-user', newUserData)
+      await userDb.del('old-format-user')
+    }
+    
+    // Mark migration as complete
+    await migrationDb.set('user-data-v2', { completed: new Date() })
+    console.log('User data migration completed')
+  }
+  
+  private transformUserData(oldData: any): any {
+    // Transform old data format to new format
+    return {
+      ...oldData,
+      version: 2,
+      migrated: true
+    }
+  }
+}
+
+// Usage
+const dbService = context.service<WebDbService>('client-db')
+const migration = new DataMigration(dbService)
+await migration.migrateUserData()
+```
+
+### Integration with React Components
+
+```typescript
+import React, { useState, useEffect } from 'react'
+import { useContext } from '@owlmeans/client'
+
+interface UserPreferences {
+  theme: string
+  language: string
+  notifications: boolean
+}
+
+function UserSettings() {
+  const context = useContext()
+  const [preferences, setPreferences] = useState<UserPreferences | null>(null)
+  const [loading, setLoading] = useState(true)
+  
+  useEffect(() => {
+    const loadPreferences = async () => {
+      try {
+        const dbService = context.service<WebDbService>('client-db')
+        const settingsDb = await dbService.initialize('user-settings')
+        
+        const saved = await settingsDb.get<UserPreferences>('preferences')
+        setPreferences(saved || {
+          theme: 'light',
+          language: 'en',
+          notifications: true
+        })
+      } catch (error) {
+        console.error('Failed to load preferences:', error)
+      } finally {
+        setLoading(false)
+      }
+    }
+    
+    loadPreferences()
+  }, [])
+  
+  const savePreferences = async (newPrefs: UserPreferences) => {
+    try {
+      const dbService = context.service<WebDbService>('client-db')
+      const settingsDb = await dbService.initialize('user-settings')
+      
+      await settingsDb.set('preferences', newPrefs)
+      setPreferences(newPrefs)
+      console.log('Preferences saved')
+    } catch (error) {
+      console.error('Failed to save preferences:', error)
+    }
+  }
+  
+  if (loading) {
+    return <div>Loading preferences...</div>
+  }
+  
+  return (
+    <div>
+      <h3>User Settings</h3>
+      <label>
+        Theme:
+        <select 
+          value={preferences?.theme} 
+          onChange={(e) => savePreferences({ ...preferences!, theme: e.target.value })}
+        >
+          <option value="light">Light</option>
+          <option value="dark">Dark</option>
+        </select>
+      </label>
+      
+      <label>
+        <input
+          type="checkbox"
+          checked={preferences?.notifications}
+          onChange={(e) => savePreferences({ ...preferences!, notifications: e.target.checked })}
+        />
+        Enable notifications
+      </label>
+    </div>
+  )
+}
+```
+
+### Advanced Database Operations
+
+```typescript
+class DatabaseManager {
+  private dbService: WebDbService
+  
+  constructor(dbService: WebDbService) {
+    this.dbService = dbService
+  }
+  
+  async exportData(): Promise<Record<string, any>> {
+    const databases = ['users', 'settings', 'cache']
+    const exportData: Record<string, any> = {}
+    
+    for (const dbName of databases) {
+      const db = await this.dbService.initialize(dbName)
+      exportData[dbName] = {}
+      
+      // Note: This is simplified - in practice you'd need to track keys
+      // or implement a proper iteration mechanism
+    }
+    
+    return exportData
+  }
+  
+  async importData(data: Record<string, any>): Promise<void> {
+    for (const [dbName, dbData] of Object.entries(data)) {
+      const db = await this.dbService.initialize(dbName)
+      
+      for (const [key, value] of Object.entries(dbData)) {
+        await db.set(key, value)
+      }
+    }
+  }
+  
+  async getStorageUsage(): Promise<{ estimated: boolean; quota?: number; usage?: number }> {
+    if ('storage' in navigator && 'estimate' in navigator.storage) {
+      return await navigator.storage.estimate()
+    }
+    return { estimated: false }
+  }
+  
+  async clearAllData(): Promise<void> {
+    await this.dbService.erase()
+    console.log('All application data cleared')
+  }
+}
+
+// Usage
+const dbService = context.service<WebDbService>('client-db')
+const dbManager = new DatabaseManager(dbService)
+
+// Check storage usage
+const usage = await dbManager.getStorageUsage()
+console.log('Storage usage:', usage)
+
+// Clear all data if needed
+// await dbManager.clearAllData()
+```
+
+## Browser Compatibility
+
+The package works in all modern browsers that support IndexedDB:
+
+- **Chrome**: 24+
+- **Firefox**: 16+
+- **Safari**: 10+
+- **Edge**: 12+
+- **Mobile browsers**: iOS 10+, Android 4.4+
+
+## Performance Considerations
+
+1. **Async Operations**: All database operations are asynchronous and return promises
+2. **Namespacing**: Each database instance is isolated for performance and organization
+3. **IndexedDB Limits**: Be aware of browser storage quotas (typically 50MB+)
+4. **Serialization**: Complex objects are automatically serialized/deserialized
+5. **Batching**: Consider batching multiple operations when possible
+
+## Error Handling
+
+```typescript
+import { WebDbService } from '@owlmeans/web-db'
+
+const handleDatabaseOperation = async () => {
+  try {
+    const dbService = context.service<WebDbService>('client-db')
+    const db = await dbService.initialize('users')
+    
+    await db.set('user123', userData)
+  } catch (error) {
+    if (error.name === 'QuotaExceededError') {
+      console.error('Storage quota exceeded')
+    } else if (error.name === 'DataError') {
+      console.error('Invalid data for storage')
+    } else {
+      console.error('Database error:', error.message)
+    }
+  }
+}
+```
+
+## Integration with Other Packages
+
+### Client Resource Integration
+```typescript
+import { appendClientResource } from '@owlmeans/client-resource'
+import { appendWebDbService } from '@owlmeans/web-db'
+
+// Setup database service first
+appendWebDbService(context)
+
+// Then setup resources that will use it
+appendClientResource(context, 'users')
+appendClientResource(context, 'settings')
+```
+
+### Context Integration
+```typescript
+import { makeClientContext } from '@owlmeans/client-context'
+import { appendWebDbService } from '@owlmeans/web-db'
+
+const context = makeClientContext(config)
+appendWebDbService(context)
+
+await context.configure().init()
+```
+
+## Best Practices
+
+1. **Namespace Usage**: Use descriptive database aliases to organize data
+2. **Error Handling**: Always handle database operation errors gracefully
+3. **Data Validation**: Validate data before storing to prevent corruption
+4. **Storage Limits**: Monitor storage usage and implement cleanup strategies
+5. **Performance**: Use appropriate data structures and avoid storing large objects
+6. **Testing**: Test database operations across different browsers
+7. **Migration**: Plan for data format changes with migration strategies
+
+## Dependencies
+
+This package depends on:
+- `@owlmeans/client-context` - Client context management
+- `@owlmeans/client-resource` - Client resource interfaces
+- `@owlmeans/context` - Core context system
+- `idb-keyval` - IndexedDB key-value library
+
+## Related Packages
+
+- [`@owlmeans/client-resource`](../client-resource) - Client resource management
+- [`@owlmeans/native-db`](../native-db) - React Native database implementation
+- [`@owlmeans/client-context`](../client-context) - Client context management
+- [`@owlmeans/web-client`](../web-client) - Web client with database integration

package/build/consts.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_ALIAS = "client-db";
+//# sourceMappingURL=consts.d.ts.map

package/build/consts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,cAAmB,CAAA"}

package/build/consts.js

@@ -0,0 +1,3 @@
+import { DEFAULT_DB_ALIAS } from '@owlmeans/client-resource';
+export const DEFAULT_ALIAS = DEFAULT_DB_ALIAS;
+//# sourceMappingURL=consts.js.map

package/build/consts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consts.js","sourceRoot":"","sources":["../src/consts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAA;AAE5D,MAAM,CAAC,MAAM,aAAa,GAAG,gBAAgB,CAAA"}

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export type * from './types.js';
+export * from './consts.js';
+export * from './service.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,mBAAmB,YAAY,CAAA;AAC/B,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA"}

package/build/index.js

@@ -0,0 +1,3 @@
+export * from './consts.js';
+export * from './service.js';
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,cAAc,aAAa,CAAA;AAC3B,cAAc,cAAc,CAAA"}

package/build/service.d.ts

@@ -0,0 +1,9 @@
+import type { WebDbService } from './types.js';
+import type { ClientConfig, ClientContext } from '@owlmeans/client-context';
+type Config = ClientConfig;
+interface Context<C extends Config = Config> extends ClientContext<C> {
+}
+export declare const makeWebDbService: (alias?: string) => WebDbService;
+export declare const appendWebDbService: <C extends Config, T extends Context<C> = Context<C>>(context: T, alias?: string) => T;
+export {};
+//# sourceMappingURL=service.d.ts.map

package/build/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAG9C,OAAO,KAAK,EAAE,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAE3E,KAAK,MAAM,GAAG,YAAY,CAAA;AAC1B,UAAU,OAAO,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,aAAa,CAAC,CAAC,CAAC;CAAI;AAEzE,eAAO,MAAM,gBAAgB,WAAW,MAAM,KAAmB,YA8ChE,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,OAAO,CAAC,CAAC,CAAC,wBAC9D,CAAC,UAAS,MAAM,KACxB,CAMF,CAAA"}

package/build/service.js

@@ -0,0 +1,46 @@
+import { createService } from '@owlmeans/context';
+import { DEFAULT_ALIAS } from './consts.js';
+import { get, set, del, clear } from 'idb-keyval';
+export const makeWebDbService = (alias = DEFAULT_ALIAS) => {
+    const stores = {};
+    const service = createService(alias, {
+        initialize: async (alias) => {
+            alias = alias ?? DEFAULT_ALIAS;
+            if (stores[alias] != null) {
+                return stores[alias];
+            }
+            const _key = (id) => alias + ':' + id;
+            const db = {
+                get: async (id) => {
+                    return await get(_key(id));
+                },
+                set: async (id, value) => {
+                    await set(_key(id), value);
+                },
+                has: async (id) => {
+                    return null != await get(_key(id));
+                },
+                del: async (id) => {
+                    const has = await db.has(id);
+                    if (has) {
+                        await del(_key(id));
+                    }
+                    return has;
+                }
+            };
+            return stores[alias] = db;
+        },
+        erase: async () => {
+            clear();
+        }
+    }, service => async () => {
+        service.initialized = true;
+    });
+    return service;
+};
+export const appendWebDbService = (context, alias = DEFAULT_ALIAS) => {
+    const service = makeWebDbService(alias);
+    context.registerService(service);
+    return context;
+};
+//# sourceMappingURL=service.js.map

package/build/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../src/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAA;AACjD,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAG3C,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,KAAK,EAAE,MAAM,YAAY,CAAA;AAMjD,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,QAAgB,aAAa,EAAgB,EAAE;IAC9E,MAAM,MAAM,GAA6B,EAAE,CAAA;IAC3C,MAAM,OAAO,GAAG,aAAa,CAAe,KAAK,EAAE;QACjD,UAAU,EAAE,KAAK,EAAC,KAAK,EAAC,EAAE;YACxB,KAAK,GAAG,KAAK,IAAI,aAAa,CAAA;YAE9B,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC;gBAC1B,OAAO,MAAM,CAAC,KAAK,CAAC,CAAA;YACtB,CAAC;YAED,MAAM,IAAI,GAAG,CAAC,EAAU,EAAE,EAAE,CAAC,KAAK,GAAG,GAAG,GAAG,EAAE,CAAA;YAE7C,MAAM,EAAE,GAAa;gBACnB,GAAG,EAAE,KAAK,EAAK,EAAU,EAAE,EAAE;oBAC3B,OAAO,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAM,CAAA;gBACjC,CAAC;gBAED,GAAG,EAAE,KAAK,EAAK,EAAU,EAAE,KAAQ,EAAE,EAAE;oBACrC,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC,CAAA;gBAC5B,CAAC;gBAED,GAAG,EAAE,KAAK,EAAC,EAAE,EAAC,EAAE;oBACd,OAAO,IAAI,IAAI,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAA;gBACpC,CAAC;gBAED,GAAG,EAAE,KAAK,EAAC,EAAE,EAAC,EAAE;oBACd,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC,CAAA;oBAC5B,IAAI,GAAG,EAAE,CAAC;wBACR,MAAM,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC,CAAA;oBACrB,CAAC;oBAED,OAAO,GAAG,CAAA;gBACZ,CAAC;aACF,CAAA;YAED,OAAO,MAAM,CAAC,KAAK,CAAC,GAAG,EAAE,CAAA;QAC3B,CAAC;QAED,KAAK,EAAE,KAAK,IAAI,EAAE;YAChB,KAAK,EAAE,CAAA;QACT,CAAC;KACF,EAAE,OAAO,CAAC,EAAE,CAAC,KAAK,IAAI,EAAE;QACvB,OAAO,CAAC,WAAW,GAAG,IAAI,CAAA;IAC5B,CAAC,CAAC,CAAA;IAEF,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAChC,OAAU,EAAE,QAAgB,aAAa,EACtC,EAAE;IACL,MAAM,OAAO,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAA;IAEvC,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAA;IAEhC,OAAO,OAAO,CAAA;AAChB,CAAC,CAAA"}

package/build/types.d.ts

@@ -0,0 +1,5 @@
+import type { ClientDbService } from '@owlmeans/client-resource';
+import type { InitializedService } from '@owlmeans/context';
+export interface WebDbService extends InitializedService, ClientDbService {
+}
+//# sourceMappingURL=types.d.ts.map

package/build/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAA;AAChE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAA;AAE3D,MAAM,WAAW,YAAa,SAAQ,kBAAkB,EAAE,eAAe;CAExE"}

package/build/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/build/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@owlmeans/web-db",
+  "version": "0.1.0",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "sleep 360 && nodemon -e ts,tsx,json --watch src --exec \"tsc -p ./tsconfig.json\"",
+    "watch": "tsc -b -w --preserveWatchOutput --pretty"
+  },
+  "main": "build/index.js",
+  "module": "build/index.js",
+  "types": "build/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./build/index.js",
+      "require": "./build/index.js",
+      "default": "./build/index.js",
+      "module": "./build/index.js",
+      "types": "./build/index.d.ts"
+    }
+  },
+  "dependencies": {
+    "@owlmeans/client-context": "^0.1.0",
+    "@owlmeans/client-resource": "^0.1.0",
+    "@owlmeans/context": "^0.1.0",
+    "idb-keyval": "^6.2.1"
+  },
+  "devDependencies": {
+    "nodemon": "^3.1.7",
+    "typescript": "^5.6.3"
+  },
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/consts.ts

@@ -0,0 +1,3 @@
+import { DEFAULT_DB_ALIAS } from '@owlmeans/client-resource'
+
+export const DEFAULT_ALIAS = DEFAULT_DB_ALIAS

package/src/index.ts

@@ -0,0 +1,4 @@
+
+export type * from './types.js'
+export * from './consts.js'
+export * from './service.js'

package/src/service.ts

@@ -0,0 +1,67 @@
+import { createService } from '@owlmeans/context'
+import { DEFAULT_ALIAS } from './consts.js'
+import type { WebDbService } from './types.js'
+import type { ClientDb } from '@owlmeans/client-resource'
+import { get, set, del, clear } from 'idb-keyval'
+import type { ClientConfig, ClientContext } from '@owlmeans/client-context'
+
+type Config = ClientConfig
+interface Context<C extends Config = Config> extends ClientContext<C> { }
+
+export const makeWebDbService = (alias: string = DEFAULT_ALIAS): WebDbService => {
+  const stores: Record<string, ClientDb> = {}
+  const service = createService<WebDbService>(alias, {
+    initialize: async alias => {
+      alias = alias ?? DEFAULT_ALIAS
+
+      if (stores[alias] != null) {
+        return stores[alias]
+      }
+
+      const _key = (id: string) => alias + ':' + id
+
+      const db: ClientDb = {
+        get: async <T>(id: string) => {
+          return await get(_key(id)) as T
+        },
+
+        set: async <T>(id: string, value: T) => {
+          await set(_key(id), value)
+        },
+
+        has: async id => {
+          return null != await get(_key(id))
+        },
+
+        del: async id => {
+          const has = await db.has(id)
+          if (has) {
+            await del(_key(id))
+          }
+
+          return has
+        }
+      }
+
+      return stores[alias] = db
+    },
+
+    erase: async () => {
+      clear()
+    }
+  }, service => async () => {
+    service.initialized = true
+  })
+
+  return service
+}
+
+export const appendWebDbService = <C extends Config, T extends Context<C> = Context<C>>(
+  context: T, alias: string = DEFAULT_ALIAS
+): T => {
+  const service = makeWebDbService(alias)
+
+  context.registerService(service)
+
+  return context
+}

package/src/types.ts

@@ -0,0 +1,6 @@
+import type { ClientDbService } from '@owlmeans/client-resource'
+import type { InitializedService } from '@owlmeans/context'
+
+export interface WebDbService extends InitializedService, ClientDbService {
+  
+}

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": [
+    "../tsconfig.default.json",
+  ],
+  "compilerOptions": {
+    "rootDir": "./src/", /* Specify the root folder within your source files. */
+    "outDir": "./build/", /* Specify an output folder for all emitted files. */
+  },
+  "exclude": [
+    "./dist/**/*",
+    "./build/**/*",
+    "./*.ts"
+  ]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/consts.ts","./src/index.ts","./src/service.ts","./src/types.ts"],"version":"5.6.3"}