@camstack/server 0.1.3

package/src/core/storage/fs-storage-backend.spec.ts

@@ -0,0 +1,70 @@
+// server/backend/src/core/storage/fs-storage-backend.spec.ts
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdirSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { FsStorageBackend } from './fs-storage-backend'
+
+describe('FsStorageBackend', () => {
+  let tempDir: string
+  let backend: FsStorageBackend
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `fs-backend-test-${Date.now()}`)
+    mkdirSync(tempDir, { recursive: true })
+    backend = new FsStorageBackend(tempDir)
+  })
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true })
+  })
+
+  it('type is local', () => {
+    expect(backend.type).toBe('local')
+  })
+
+  it('basePath is resolved to absolute', () => {
+    const relative = new FsStorageBackend('./relative/path')
+    expect(relative.basePath).toContain('/')
+    expect(relative.basePath).not.toContain('./')
+  })
+
+  it('resolve joins subpath', () => {
+    expect(backend.resolve('models/yolov8n.onnx')).toBe(join(tempDir, 'models/yolov8n.onnx'))
+  })
+
+  it('resolve returns absolute paths as-is', () => {
+    expect(backend.resolve('/absolute/path')).toBe('/absolute/path')
+  })
+
+  it('isAvailable returns true for existing writable dir', () => {
+    expect(backend.isAvailable()).toBe(true)
+  })
+
+  it('isAvailable returns false when no existing ancestor is writable', () => {
+    // Nothing under /nonexistent exists, so no writable ancestor →
+    // the backend cannot be created when needed.
+    const missing = new FsStorageBackend('/nonexistent/path/xyz')
+    expect(missing.isAvailable()).toBe(false)
+  })
+
+  it('isAvailable returns true for a not-yet-existing dir whose parent is writable', () => {
+    // Lazy creation: the backend reports itself as available when the
+    // nearest existing ancestor (tempDir) is writable, because we can
+    // `mkdir -p` the missing segments on first write.
+    const notYet = new FsStorageBackend(join(tempDir, 'sub', 'dir'))
+    expect(notYet.isAvailable()).toBe(true)
+  })
+
+  it('initialize is a no-op — directory is created lazily on first write', async () => {
+    const { existsSync } = await import('node:fs')
+    const newPath = join(tempDir, 'sub', 'dir')
+    const newBackend = new FsStorageBackend(newPath)
+    // The base dir doesn't exist yet, but the ancestor chain is
+    // writable — so the backend is available and initialize is a
+    // no-op (doesn't create the dir eagerly).
+    expect(newBackend.isAvailable()).toBe(true)
+    await newBackend.initialize()
+    expect(existsSync(newPath)).toBe(false)
+  })
+})

package/src/core/storage/fs-storage-backend.ts

@@ -0,0 +1,3 @@
+// Re-export from @camstack/core
+export { FsStorageBackend } from '@camstack/core'
+export type { IStorageBackend } from '@camstack/core'

package/src/core/storage/settings-store.spec.ts

@@ -0,0 +1,213 @@
+ 
+// server/backend/src/core/storage/settings-store.spec.ts
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { SettingsStore } from './settings-store'
+import { RUNTIME_DEFAULTS } from '../config/config.schema'
+
+// Use an in-memory SQLite DB for tests so no temp files are created.
+function makeStore(): SettingsStore {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-call -- 
+  return new (SettingsStore as any)(':memory:') as SettingsStore
+}
+
+// Re-open the private constructor with ':memory:' by temporarily patching the
+// constructor argument. SettingsStore accepts a dbPath string; ':memory:' is
+// the special better-sqlite3 in-memory sentinel.
+function createStore(): SettingsStore {
+  return new SettingsStore(':memory:')
+}
+
+describe('SettingsStore — system settings', () => {
+  let store: SettingsStore
+
+  beforeEach(() => { store = createStore() })
+  afterEach(() => { store.close() })
+
+  it('returns undefined for a key that does not exist', () => {
+    expect(store.getSystem('nonexistent')).toBeUndefined()
+  })
+
+  it('stores and retrieves a string value', () => {
+    store.setSystem('logging.level', 'debug')
+    expect(store.getSystem('logging.level')).toBe('debug')
+  })
+
+  it('stores and retrieves a number value', () => {
+    store.setSystem('retention.days', 30)
+    expect(store.getSystem('retention.days')).toBe(30)
+  })
+
+  it('stores and retrieves a boolean value', () => {
+    store.setSystem('features.streaming', true)
+    expect(store.getSystem('features.streaming')).toBe(true)
+  })
+
+  it('stores and retrieves a nested object (JSON serialization)', () => {
+    const obj = { a: 1, b: [1, 2, 3], c: { nested: true } }
+    store.setSystem('complex.key', obj)
+    expect(store.getSystem('complex.key')).toEqual(obj)
+  })
+
+  it('overwrites an existing key', () => {
+    store.setSystem('logging.level', 'info')
+    store.setSystem('logging.level', 'warn')
+    expect(store.getSystem('logging.level')).toBe('warn')
+  })
+
+  it('getAllSystem returns all stored keys', () => {
+    store.setSystem('key.a', 1)
+    store.setSystem('key.b', 2)
+    const all = store.getAllSystem()
+    expect(all['key.a']).toBe(1)
+    expect(all['key.b']).toBe(2)
+  })
+
+  it('getAllSystem returns empty object when no keys are set', () => {
+    expect(store.getAllSystem()).toEqual({})
+  })
+})
+
+describe('SettingsStore — addon settings', () => {
+  let store: SettingsStore
+
+  beforeEach(() => { store = createStore() })
+  afterEach(() => { store.close() })
+
+  it('returns undefined for a missing addon key', () => {
+    expect(store.getAddon('sqlite-storage', 'dbPath')).toBeUndefined()
+  })
+
+  it('stores and retrieves a value scoped by addonId', () => {
+    store.setAddon('sqlite-storage', 'dbPath', '/data/camstack.db')
+    expect(store.getAddon('sqlite-storage', 'dbPath')).toBe('/data/camstack.db')
+  })
+
+  it('scopes values: different addons do not share keys', () => {
+    store.setAddon('addon-a', 'sharedKey', 'value-a')
+    store.setAddon('addon-b', 'sharedKey', 'value-b')
+    expect(store.getAddon('addon-a', 'sharedKey')).toBe('value-a')
+    expect(store.getAddon('addon-b', 'sharedKey')).toBe('value-b')
+  })
+
+  it('getAllAddon returns only keys for the requested addon', () => {
+    store.setAddon('addon-a', 'key1', 10)
+    store.setAddon('addon-a', 'key2', 20)
+    store.setAddon('addon-b', 'key1', 99)
+    const all = store.getAllAddon('addon-a')
+    expect(all).toEqual({ key1: 10, key2: 20 })
+  })
+
+  it('setAllAddon replaces all keys atomically', () => {
+    store.setAddon('my-addon', 'old', 'gone')
+    store.setAllAddon('my-addon', { newKey: 'newVal', another: 42 })
+    const all = store.getAllAddon('my-addon')
+    expect(all).toEqual({ newKey: 'newVal', another: 42 })
+    expect(store.getAddon('my-addon', 'old')).toBeUndefined()
+  })
+
+  it('setAllAddon does not affect other addons', () => {
+    store.setAddon('other-addon', 'keep', 'me')
+    store.setAllAddon('my-addon', { x: 1 })
+    expect(store.getAddon('other-addon', 'keep')).toBe('me')
+  })
+})
+
+describe('SettingsStore — provider settings', () => {
+  let store: SettingsStore
+
+  beforeEach(() => { store = createStore() })
+  afterEach(() => { store.close() })
+
+  it('returns undefined for a missing provider key', () => {
+    expect(store.getProvider('prov-1', 'url')).toBeUndefined()
+  })
+
+  it('stores and retrieves a provider value', () => {
+    store.setProvider('prov-1', 'url', 'http://localhost:8554')
+    expect(store.getProvider('prov-1', 'url')).toBe('http://localhost:8554')
+  })
+
+  it('scopes values between providers', () => {
+    store.setProvider('prov-1', 'url', 'http://host-a')
+    store.setProvider('prov-2', 'url', 'http://host-b')
+    expect(store.getProvider('prov-1', 'url')).toBe('http://host-a')
+    expect(store.getProvider('prov-2', 'url')).toBe('http://host-b')
+  })
+
+  it('getAllProvider returns all keys for a provider', () => {
+    store.setProvider('prov-1', 'url', 'http://x')
+    store.setProvider('prov-1', 'port', 8554)
+    expect(store.getAllProvider('prov-1')).toEqual({ url: 'http://x', port: 8554 })
+  })
+})
+
+describe('SettingsStore — device settings', () => {
+  let store: SettingsStore
+
+  beforeEach(() => { store = createStore() })
+  afterEach(() => { store.close() })
+
+  it('returns undefined for a missing device key', () => {
+    expect(store.getDevice('cam-1', 'label')).toBeUndefined()
+  })
+
+  it('stores and retrieves a device value', () => {
+    store.setDevice('cam-1', 'label', 'Front Door')
+    expect(store.getDevice('cam-1', 'label')).toBe('Front Door')
+  })
+
+  it('scopes values between devices', () => {
+    store.setDevice('cam-1', 'label', 'A')
+    store.setDevice('cam-2', 'label', 'B')
+    expect(store.getDevice('cam-1', 'label')).toBe('A')
+    expect(store.getDevice('cam-2', 'label')).toBe('B')
+  })
+
+  it('getAllDevice returns all keys for a device', () => {
+    store.setDevice('cam-1', 'label', 'Cam 1')
+    store.setDevice('cam-1', 'enabled', true)
+    expect(store.getAllDevice('cam-1')).toEqual({ label: 'Cam 1', enabled: true })
+  })
+})
+
+describe('SettingsStore — first boot seeding', () => {
+  let store: SettingsStore
+
+  beforeEach(() => { store = createStore() })
+  afterEach(() => { store.close() })
+
+  it('isSystemSettingsEmpty returns true on a fresh DB', () => {
+    expect(store.isSystemSettingsEmpty()).toBe(true)
+  })
+
+  it('seedDefaults populates system_settings with RUNTIME_DEFAULTS', () => {
+    store.seedDefaults()
+    expect(store.isSystemSettingsEmpty()).toBe(false)
+    for (const [key, expected] of Object.entries(RUNTIME_DEFAULTS)) {
+      expect(store.getSystem(key)).toEqual(expected)
+    }
+  })
+
+  it('seedDefaults does not overwrite existing values (INSERT OR IGNORE)', () => {
+    store.setSystem('logging.level', 'debug')
+    store.seedDefaults()
+    // The manually set value should survive — seedDefaults uses INSERT OR IGNORE
+    expect(store.getSystem('logging.level')).toBe('debug')
+  })
+
+  it('second boot: seedDefaults is skipped when table is not empty', () => {
+    store.seedDefaults()
+    // Simulate a manual override then "re-boot"
+    store.setSystem('logging.level', 'warn')
+
+    // On second boot we would call seedDefaults only when isEmpty — simulate that guard
+    if (!store.isSystemSettingsEmpty()) {
+      // No-op: skip seeding
+    } else {
+      store.seedDefaults()
+    }
+
+    // Value from first seed should remain (not reverted to RUNTIME_DEFAULTS)
+    expect(store.getSystem('logging.level')).toBe('warn')
+  })
+})

package/src/core/storage/settings-store.ts

@@ -0,0 +1,2 @@
+// Re-export from @camstack/core (sqlite-storage builtin)
+export { SettingsStore } from '@camstack/core'

package/src/core/storage/sql-schema.spec.ts

@@ -0,0 +1,140 @@
+// server/backend/src/core/storage/sql-schema.spec.ts
+import { describe, it, expect } from 'vitest'
+import { addonTableToDdl, CORE_TABLE_DDL, type AddonTableSchema } from './sql-schema'
+
+describe('CORE_TABLE_DDL', () => {
+  it('is a non-empty readonly array of strings', () => {
+    expect(CORE_TABLE_DDL.length).toBeGreaterThan(0)
+    for (const stmt of CORE_TABLE_DDL) {
+      expect(typeof stmt).toBe('string')
+      expect(stmt.length).toBeGreaterThan(0)
+    }
+  })
+
+  it('contains CREATE TABLE IF NOT EXISTS for core tables', () => {
+    // `detection_events`, `audio_levels`, `track_trails` were removed
+    // in the P12b sweep — they're now owned by `addon-pipeline-analytics`
+    // via `declareCollection` (pipeline-analytics:motion-events,
+    // :object-events, :audio-events, :tracks, :media). The hub-core
+    // DDL only carries the foundational settings + device registry
+    // tables.
+    const tables = ['system_settings', 'addon_settings', 'provider_settings', 'device_settings', 'devices']
+    for (const table of tables) {
+      const found = CORE_TABLE_DDL.some(stmt => stmt.includes(`CREATE TABLE IF NOT EXISTS ${table}`))
+      expect(found, `Expected DDL for table "${table}"`).toBe(true)
+    }
+  })
+
+  it('contains indexes for the devices table', () => {
+    const found = CORE_TABLE_DDL.some(stmt => stmt.includes('idx_devices_addon'))
+    expect(found).toBe(true)
+  })
+})
+
+describe('addonTableToDdl', () => {
+  it('generates a CREATE TABLE statement with single primary key', () => {
+    const schema: AddonTableSchema = {
+      name: 'my_addon_events',
+      columns: [
+        { name: 'id', type: 'TEXT', primaryKey: true },
+        { name: 'timestamp', type: 'INTEGER', notNull: true },
+        { name: 'payload', type: 'JSON' },
+      ],
+    }
+
+    const stmts = addonTableToDdl(schema)
+    expect(stmts).toHaveLength(1)
+    const ddl = stmts[0]
+    expect(ddl).toContain('CREATE TABLE IF NOT EXISTS my_addon_events')
+    expect(ddl).toContain('id TEXT')
+    expect(ddl).toContain('timestamp INTEGER NOT NULL')
+    expect(ddl).toContain('payload JSON')
+    expect(ddl).toContain('PRIMARY KEY (id)')
+  })
+
+  it('generates a CREATE TABLE with composite primary key', () => {
+    const schema: AddonTableSchema = {
+      name: 'composite_pk_table',
+      columns: [
+        { name: 'addon_id', type: 'TEXT', primaryKey: true, notNull: true },
+        { name: 'key', type: 'TEXT', primaryKey: true, notNull: true },
+        { name: 'value', type: 'JSON', notNull: true },
+      ],
+    }
+
+    const stmts = addonTableToDdl(schema)
+    expect(stmts[0]).toContain('PRIMARY KEY (addon_id, key)')
+    expect(stmts[0]).toContain('addon_id TEXT NOT NULL')
+    expect(stmts[0]).toContain('key TEXT NOT NULL')
+  })
+
+  it('generates indexes when provided', () => {
+    const schema: AddonTableSchema = {
+      name: 'indexed_table',
+      columns: [
+        { name: 'id', type: 'TEXT', primaryKey: true },
+        { name: 'device_id', type: 'TEXT', notNull: true },
+        { name: 'ts', type: 'INTEGER', notNull: true },
+      ],
+      indexes: [
+        { name: 'idx_indexed_device_ts', columns: ['device_id', 'ts'] },
+        { name: 'idx_unique_id', columns: ['id'], unique: true },
+      ],
+    }
+
+    const stmts = addonTableToDdl(schema)
+    expect(stmts).toHaveLength(3)
+    expect(stmts[1]).toContain('CREATE INDEX IF NOT EXISTS idx_indexed_device_ts ON indexed_table(device_id, ts)')
+    expect(stmts[2]).toContain('CREATE UNIQUE INDEX IF NOT EXISTS idx_unique_id ON indexed_table(id)')
+  })
+
+  it('generates no PRIMARY KEY clause when no column is marked primaryKey', () => {
+    const schema: AddonTableSchema = {
+      name: 'no_pk_table',
+      columns: [
+        { name: 'col1', type: 'TEXT' },
+        { name: 'col2', type: 'INTEGER' },
+      ],
+    }
+
+    const stmts = addonTableToDdl(schema)
+    expect(stmts[0]).not.toContain('PRIMARY KEY')
+  })
+
+  it('produces valid SQL string (no syntax placeholders)', () => {
+    const schema: AddonTableSchema = {
+      name: 'valid_sql_table',
+      columns: [
+        { name: 'id', type: 'TEXT', primaryKey: true },
+        { name: 'data', type: 'JSON' },
+      ],
+    }
+
+    const stmts = addonTableToDdl(schema)
+    for (const stmt of stmts) {
+      // Should not contain template placeholders or undefined
+      expect(stmt).not.toContain('undefined')
+      expect(stmt).not.toContain('${')
+      expect(stmt.trim().length).toBeGreaterThan(0)
+    }
+  })
+
+  it('handles all column types correctly', () => {
+    const schema: AddonTableSchema = {
+      name: 'all_types',
+      columns: [
+        { name: 'text_col', type: 'TEXT' },
+        { name: 'int_col', type: 'INTEGER' },
+        { name: 'real_col', type: 'REAL' },
+        { name: 'json_col', type: 'JSON' },
+      ],
+    }
+
+    const stmts = addonTableToDdl(schema)
+    const ddl = stmts[0]
+    expect(ddl).toContain('text_col TEXT')
+    expect(ddl).toContain('int_col INTEGER')
+    expect(ddl).toContain('real_col REAL')
+    expect(ddl).toContain('json_col JSON')
+  })
+})

package/src/core/storage/sql-schema.ts

@@ -0,0 +1,3 @@
+// Re-export from @camstack/core (sqlite-storage builtin)
+export { CORE_TABLE_DDL, addonTableToDdl } from '@camstack/core'
+export type { AddonTableSchema } from '@camstack/core'

package/src/core/storage/storage-location-manager.spec.ts

@@ -0,0 +1,121 @@
+// server/backend/src/core/storage/storage-location-manager.spec.ts
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { existsSync, mkdirSync, rmSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { StorageLocationManager, type StorageLocationName } from './storage-location-manager'
+
+describe('StorageLocationManager', () => {
+  let tempDir: string
+  let manager: StorageLocationManager
+
+  beforeEach(() => {
+    tempDir = join(tmpdir(), `slm-test-${Date.now()}`)
+    mkdirSync(tempDir, { recursive: true })
+    manager = new StorageLocationManager(tempDir)
+  })
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true })
+    rmSync('/tmp/camstack-cache', { recursive: true, force: true })
+  })
+
+  it('initializeDefaults registers all 6 location backends', async () => {
+    await manager.initializeDefaults()
+    const names = manager.getLocationNames()
+    expect(names).toHaveLength(6)
+    expect(names).toContain('data')
+    expect(names).toContain('media')
+    expect(names).toContain('recordings')
+    expect(names).toContain('models')
+    expect(names).toContain('cache')
+    expect(names).toContain('logs')
+  })
+
+  it('initializeDefaults does NOT create the location directories on disk (lazy)', async () => {
+    await manager.initializeDefaults()
+    // None of the 6 location paths should exist — directories are
+    // created on first write by the filesystem storage provider, not
+    // eagerly at boot. This is the anti-bloat invariant: a fresh
+    // installation should not materialise empty `recordings/`,
+    // `media/`, `logs/` folders just because StorageLocationManager
+    // was initialized.
+    expect(existsSync(join(tempDir, 'db'))).toBe(false)
+    expect(existsSync(join(tempDir, 'media'))).toBe(false)
+    expect(existsSync(join(tempDir, 'recordings'))).toBe(false)
+    expect(existsSync(join(tempDir, 'models'))).toBe(false)
+    expect(existsSync(join(tempDir, 'logs'))).toBe(false)
+  })
+
+  it('initializeDefaults reports all locations as available (parent dir writable)', async () => {
+    await manager.initializeDefaults()
+    const status = manager.getStatus()
+    // A backend is "available" as long as it can be created when
+    // needed (nearest existing ancestor is writable). Since `tempDir`
+    // exists and is writable, every location underneath it is
+    // available even though the location dir itself does not yet
+    // exist.
+    for (const entry of status) {
+      expect(entry.available).toBe(true)
+    }
+  })
+
+  it('getLocationNames returns all 6 location names', async () => {
+    await manager.initializeDefaults()
+    const names = manager.getLocationNames()
+    const expected: StorageLocationName[] = ['data', 'media', 'recordings', 'models', 'cache', 'logs']
+    expect(names.sort()).toEqual(expected.sort())
+  })
+
+  it('resolve joins subpath correctly within a location', async () => {
+    await manager.initializeDefaults()
+    const resolved = manager.resolve('data', 'camstack.db')
+    expect(resolved).toBe(join(tempDir, 'db', 'camstack.db'))
+  })
+
+  it('resolve for cache uses /tmp/camstack-cache base', async () => {
+    await manager.initializeDefaults()
+    const resolved = manager.resolve('cache', 'thumbnails')
+    expect(resolved).toBe('/tmp/camstack-cache/thumbnails')
+  })
+
+  it('setLocationPath overrides a location with absolute path', async () => {
+    await manager.initializeDefaults()
+    const newPath = join(tempDir, 'custom-media')
+    await manager.setLocationPath('media', newPath)
+    const backend = manager.getBackend('media')
+    expect(backend.basePath).toBe(newPath)
+    // Still lazy — overriding the path doesn't eagerly create it.
+    expect(backend.isAvailable()).toBe(true)
+    expect(existsSync(newPath)).toBe(false)
+  })
+
+  it('setLocationPath overrides a location with relative path (resolved against dataPath)', async () => {
+    await manager.initializeDefaults()
+    await manager.setLocationPath('logs', 'custom-logs')
+    const backend = manager.getBackend('logs')
+    expect(backend.basePath).toBe(join(tempDir, 'custom-logs'))
+    expect(backend.isAvailable()).toBe(true)
+  })
+
+  it('getStatus reports all locations with name, available, path', async () => {
+    await manager.initializeDefaults()
+    const status = manager.getStatus()
+    expect(status).toHaveLength(6)
+    for (const entry of status) {
+      expect(entry).toHaveProperty('name')
+      expect(entry).toHaveProperty('available')
+      expect(entry).toHaveProperty('path')
+      expect(typeof entry.available).toBe('boolean')
+    }
+  })
+
+  it('missing location throws error', () => {
+    // not initialized
+    expect(() => manager.getBackend('data')).toThrow('Storage location "data" not initialized')
+  })
+
+  it('resolve on uninitialized location throws error', () => {
+    expect(() => manager.resolve('media', 'file.mp4')).toThrow('Storage location "media" not initialized')
+  })
+})

package/src/core/storage/storage-location-manager.ts

@@ -0,0 +1,3 @@
+// Re-export from @camstack/core
+export { StorageLocationManager } from '@camstack/core'
+export type { StorageLocationName } from '@camstack/core'

package/src/core/storage/storage.service.spec.ts

@@ -0,0 +1,73 @@
+import { describe, it, expect, vi } from 'vitest'
+import { StorageService } from './storage.service'
+import type { ICoreStorageProvider as IStorageProvider, IStorageLocation } from '@camstack/core'
+
+const createMockProvider = (): IStorageProvider => {
+  const mockLocation: IStorageLocation = { structured: undefined, files: undefined }
+  return {
+    initialize: vi.fn(),
+    shutdown: vi.fn(),
+    getLocation: vi.fn().mockReturnValue(mockLocation),
+    export: vi.fn(),
+    import: vi.fn(),
+  }
+}
+
+describe('StorageService', () => {
+  const createService = (): StorageService => {
+    return new StorageService()
+  }
+
+  it('delegates getLocation to active provider', () => {
+    const service = createService()
+    const provider = createMockProvider()
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    service.setProvider(provider)
+
+    const result = service.getLocation('data')
+
+    expect(provider.getLocation).toHaveBeenCalledWith('data')
+    expect(result).toBeDefined()
+  })
+
+  it('maps legacy location names to new names', () => {
+    const service = createService()
+    const provider = createMockProvider()
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    service.setProvider(provider)
+
+    // Legacy 'config' and 'events' both map to 'data'.
+    // StorageManager.getLocation accepts `StorageLocationName | string`,
+    // so string literals flow through without casts.
+    service.getLocation('config')
+    expect(provider.getLocation).toHaveBeenCalledWith('data')
+
+    service.getLocation('events')
+    expect(provider.getLocation).toHaveBeenNthCalledWith(2, 'data')
+  })
+
+  it('throws if no provider set', () => {
+    const service = createService()
+
+    expect(() => service.getLocation('data')).toThrow('No storage provider configured')
+    expect(() => service.getProvider()).toThrow('No storage provider configured')
+  })
+
+  it('setProvider changes the active provider', () => {
+    const service = createService()
+    const provider1 = createMockProvider()
+    const provider2 = createMockProvider()
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    service.setProvider(provider1)
+    expect(service.getProvider()).toBe(provider1)
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated
+    service.setProvider(provider2)
+    expect(service.getProvider()).toBe(provider2)
+
+    service.getLocation('data')
+    expect(provider2.getLocation).toHaveBeenCalledWith('data')
+    expect(provider1.getLocation).not.toHaveBeenCalled()
+  })
+})

package/src/core/storage/storage.service.ts

@@ -0,0 +1,3 @@
+import { StorageManager } from '@camstack/core'
+
+export class StorageService extends StorageManager {}