2.0.0

.github/workflows/checks.yaml

@@ -104,10 +104,13 @@ jobs:
           path: |
             **/node_modules
           key: ${{ runner.OS }}-modules-${{ matrix.node-version }}-${{ hashFiles('**/package-lock.json') }}
-      - name: unit testing
+      - name: prebuild packages
         run: |
           npm run build -w packages/base/core
+          npm run build -w packages/storage-adapters/generic-fs
           npm run build -w packages/devtools/devtools
+      - name: unit testing
+        run: |
           npm test -- --coverage --outputFile=test-report.junit.xml run
       - name: Upload coverage reports to Codecov
         uses: codecov/codecov-action@v5

.scripts/build-all.js

@@ -0,0 +1,166 @@
+#!/usr/bin/env node
+'use strict'
+
+const fs = require('fs')
+const path = require('path')
+const { spawn } = require('child_process')
+const os = require('os')
+
+// --- Helpers ---------------------------------------------------------------
+function runNpmBuild(cwd, options = {}) {
+  const { verbose = process.env.BUILD_VERBOSE === '1' || process.env.BUILD_VERBOSE === 'true' } = options
+  return new Promise((resolve, reject) => {
+    const cmd = process.platform === 'win32' ? 'npm.cmd' : 'npm'
+    const args = ['run', '-s', 'build'] // -s/--silent to quiet npm itself
+
+    const child = spawn(cmd, args, {
+      cwd,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
+
+    let stdoutBuf = ''
+    let stderrBuf = ''
+
+    child.stdout.on('data', (chunk) => {
+      if (verbose) {
+        process.stdout.write(chunk)
+      } else {
+        stdoutBuf += chunk.toString()
+      }
+    })
+
+    child.stderr.on('data', (chunk) => {
+      if (verbose) {
+        process.stderr.write(chunk)
+      } else {
+        stderrBuf += chunk.toString()
+      }
+    })
+
+    child.on('error', reject)
+    child.on('close', (code) => {
+      if (code === 0) return resolve()
+      const tail = (stdoutBuf + '\n' + stderrBuf)
+        .split(/\r?\n/)
+        .slice(-40)
+        .join('\n')
+      const error = new Error(`Build failed in ${cwd} (exit code ${code}).\n--- Last output ---\n${tail}`)
+      reject(error)
+    })
+  })
+}
+async function runInPool(items, worker, concurrency) {
+  const results = Array.from({ length: items.length })
+  let index = 0
+  const workers = []
+  const errors = []
+  const runWorker = async () => {
+    while (true) {
+      const i = index++
+      if (i >= items.length) break
+      try {
+        results[i] = await worker(items[i], i)
+      } catch (error) {
+        errors.push(error)
+      }
+    }
+  }
+  const workerCount = Math.min(concurrency, items.length)
+  for (let i = 0; i < workerCount; i++) {
+    workers.push(runWorker())
+  }
+  await Promise.all(workers)
+  if (errors.length > 0) throw errors[0]
+  return results
+}
+
+async function listSubdirs(directory) {
+  try {
+    const entries = await fs.promises.readdir(directory, { withFileTypes: true })
+    return entries
+      .filter(entry => entry.isDirectory())
+      .map(entry => path.join(directory, entry.name))
+  } catch {
+    return []
+  }
+}
+
+async function hasBuildScript(directory) {
+  try {
+    const packageJson = await fs.promises.readFile(path.join(directory, 'package.json'), 'utf8')
+    const package_ = JSON.parse(packageJson)
+    return Boolean(package_ && package_.scripts && package_.scripts.build)
+  } catch {
+    return false
+  }
+}
+
+// --- Main -----------------------------------------------------------------
+(async function main() {
+  const repoRoot = path.resolve(__dirname, '..')
+
+  // 1) Build base/core first
+  const coreDirectory = path.join(repoRoot, 'packages', 'base', 'core')
+  await runNpmBuild(coreDirectory)
+  console.log(`Built ${path.relative(repoRoot, coreDirectory)}`)
+
+  // 2) Build storage-adapters/generic-fs second
+  const genericFsDirectory = path.join(
+    repoRoot,
+    'packages',
+    'storage-adapters',
+    'generic-fs',
+  )
+  await runNpmBuild(genericFsDirectory)
+  console.log(`Built ${path.relative(repoRoot, genericFsDirectory)}`)
+
+  // 3) Build everything else in parallel
+  const groups = [
+    { dir: path.join(repoRoot, 'packages', 'base'), exclude: new Set(['core']) },
+    { dir: path.join(repoRoot, 'packages', 'devtools'), exclude: new Set() },
+    { dir: path.join(repoRoot, 'packages', 'integrations'), exclude: new Set() },
+    {
+      dir: path.join(repoRoot, 'packages', 'storage-adapters'),
+      exclude: new Set(['generic-fs']),
+    },
+    { dir: path.join(repoRoot, 'packages', 'reactivity-adapters'), exclude: new Set() },
+  ]
+
+  /** Collect package directories that actually have a build script */
+  const directoriesToBuild = []
+  for (const g of groups) {
+    const subdirs = await listSubdirs(g.dir)
+    for (const d of subdirs) {
+      const name = path.basename(d)
+      if (g.exclude.has(name)) continue
+      if (await hasBuildScript(d)) {
+        directoriesToBuild.push(d)
+      } else {
+        console.log(`[skip] ${path.relative(repoRoot, d)} (no npm run build)`)
+      }
+    }
+  }
+
+  if (directoriesToBuild.length === 0) {
+    console.log('Nothing else to build.')
+    return
+  }
+
+  const cpuCount = os.cpus ? os.cpus().length : 1
+  const maxConcurrency = Math.max(1, Number.parseInt(process.env.BUILD_CONCURRENCY || '', 10) || cpuCount)
+
+  console.log(`Building ${directoriesToBuild.length} packages in parallel (up to ${maxConcurrency} workers)`)
+  await runInPool(
+    directoriesToBuild,
+    async (directory) => {
+      await runNpmBuild(directory)
+      console.log(`Built ${path.relative(repoRoot, directory)}`)
+    },
+    maxConcurrency,
+  )
+
+  console.log('✅ All builds completed successfully.')
+})().catch((error) => {
+  console.error('❌ build-all failed:\n', error && error.stack ? error.stack : error)
+  process.exit(1)
+})

CONTRIBUTING.md

@@ -22,7 +22,7 @@ All packages are in the `packages` folder. In the folder are some sub-folders to
     - `sync`: Contains `@signaldb/sync`
   - `integrations`: Contains all integrations to frameworks like React for example.
   - `reactivity-adapters`: Contains all reactivity adapters of SignalDB.
-  - `persistence-adapters`: Contains all persistence adapters of SignalDB.
+  - `storage-adapters`: Contains all storage adapters of SignalDB.
 
 ## ✅ Committing your changes
 

docs/.vitepress/config.mts

@@ -59,12 +59,13 @@ export default withMermaid({
             { text: 'Core Concepts', link: '/core-concepts/' },
             { text: 'Querying Data', link: '/queries/' },
             { text: 'Data manipulation', link: '/data-manipulation/' },
-            { text: 'Data Persistence', link: '/data-persistence/' },
+            { text: 'Data Storage', link: '/data-persistence/' },
             { text: 'Reactivity', link: '/reactivity/' },
             { text: 'Synchronization', link: '/sync/' },
             { text: 'ORM', link: '/orm/' },
             { text: 'Developer Tools', link: '/devtools/' },
             { text: 'Schema Validation', link: '/schema-validation/' },
+            { text: 'Upgrade to v2', link: '/upgrade/v2/' },
             { text: 'Upgrade to v1', link: '/upgrade/v1/' },
           ],
         },
@@ -156,9 +157,8 @@ export default withMermaid({
                 { text: 'createIndex', link: '/reference/core/createindex/' },
                 { text: 'createIndexProvider', link: '/reference/core/createindexprovider/' },
                 { text: 'createMemoryAdapter', link: '/reference/core/creatememoryadapter/' },
-                { text: 'createPersistenceAdapter', link: '/reference/core/createpersistenceadapter/' },
+                { text: 'createStorageAdapter', link: '/reference/core/createstorageadapter/' },
                 { text: 'createReactivityAdapter', link: '/reference/core/createreactivityadapter/' },
-                { text: 'combinePersistenceAdapters', link: '/reference/core/combinepersistenceadapters/' },
               ],
             },
             { text: '@signaldb/sync', link: '/reference/sync/' },
@@ -171,7 +171,7 @@ export default withMermaid({
           ],
         },
         {
-          text: 'Persistence Adapters',
+          text: 'Storage Adapters',
           items: [
             { text: '@signaldb/fs', link: '/reference/fs/' },
             { text: '@signaldb/indexeddb', link: '/reference/indexeddb/' },
@@ -311,6 +311,7 @@ export default withMermaid({
       '/reactivity/vue.html': '/reference/vue/',
       '/reactivity/vue/index.html': '/reference/vue/',
       '/reference/core/index.html': '/reference/',
+      '/reference/core/createpersistenceadapter/index.html': '/reference/core/createstorageadapter/',
       '/replication.html': '/sync/',
       '/replication/appwrite/index.html': '/sync/',
       '/replication/firebase/index.html': '/sync/',

docs/changelog/fs/index.md

@@ -1,3 +1,3 @@
 # Changelog for [`@signaldb/fs`](https://www.npmjs.com/package/@signaldb/fs)
 
-<!--@include: ../../../packages/persistence-adapters/fs/CHANGELOG.md{10,}-->
+<!--@include: ../../../packages/storage-adapters/fs/CHANGELOG.md{10,}-->

docs/changelog/indexeddb/index.md

@@ -1,3 +1,3 @@
 # Changelog for [`@signaldb/indexeddb`](https://www.npmjs.com/package/@signaldb/indexeddb)
 
-<!--@include: ../../../packages/persistence-adapters/indexeddb/CHANGELOG.md{10,}-->
+<!--@include: ../../../packages/storage-adapters/indexeddb/CHANGELOG.md{10,}-->

docs/changelog/localstorage/index.md

@@ -1,3 +1,3 @@
 # Changelog for [`@signaldb/localstorage`](https://www.npmjs.com/package/@signaldb/localstorage)
 
-<!--@include: ../../../packages/persistence-adapters/localstorage/CHANGELOG.md{10,}-->
+<!--@include: ../../../packages/storage-adapters/localstorage/CHANGELOG.md{10,}-->

docs/changelog/opfs/index.md

@@ -1,3 +1,3 @@
 # Changelog for [`@signaldb/opfs`](https://www.npmjs.com/package/@signaldb/opfs)
 
-<!--@include: ../../../packages/persistence-adapters/opfs/CHANGELOG.md{10,}-->
+<!--@include: ../../../packages/storage-adapters/opfs/CHANGELOG.md{10,}-->

docs/core-concepts/index.md

@@ -70,12 +70,12 @@ You can also create a MemoryAdapter on your own. See the [createMemoryAdapter re
 
 SignalDB only stores the data in memory and it will be lost when the memory is flushed (e.g. page reload).
 
-Normally you don't want to lose data and you want to persist it. This is where persistence adapters come in.
+Normally you don't want to lose data and you want to persist it. This is where storage adapters come in.
 
-Persistence adapters in SignalDB play a critical role in ensuring that your data remains intact across multiple user sessions or application reloads. These adapters facilitate data persistence by providing a standard interface for storing and retrieving data, thereby abstracting from the specifics of the underlying storage mechanism.
+Storage adapters in SignalDB play a critical role in ensuring that your data remains intact across multiple user sessions or application reloads. These adapters facilitate data persistence by providing a standard interface for storing and retrieving data, thereby abstracting from the specifics of the underlying storage mechanism.
 
-A persistence adapter provides the necessary code to interact with a specific storage medium, such as localStorage, IndexedDB, or even a remote server. The role of the adapter is to translate the high-level operations that you perform on your data (such as saving or loading a document) into low-level operations that the storage medium can understand.
+A storage adapter provides the necessary code to interact with a specific storage medium, such as localStorage, IndexedDB, or even a remote server. The role of the adapter is to translate the high-level operations that you perform on your data (such as saving or loading a document) into low-level operations that the storage medium can understand.
 
-The main benefit of using persistence adapters is flexibility. Because they provide an abstraction layer over the storage system, you can switch between different storage systems with minimal impact on the rest of your code.
+The main benefit of using storage adapters is flexibility. Because they provide an abstraction layer over the storage system, you can switch between different storage systems with minimal impact on the rest of your code.
 
-See also the [persistence adapters](/data-persistence/) documentation page.
+See also the [storage adapters](/data-persistence/) documentation page.

docs/data-persistence/index.md

@@ -11,33 +11,33 @@ head:
     content: https://signaldb.js.org/data-persistence/
 - - meta
   - name: og:title
-    content: Data Persistence Adapters | SignalDB
+    content: Storage Adapters | SignalDB
 - - meta
   - name: og:description
-    content: Learn how Data Persistence Adapters in SignalDB provide an abstraction layer over different storage systems like localStorage, IndexedDB, and remote servers.
+    content: Learn how Storage Adapters in SignalDB provide an abstraction layer over different storage systems like localStorage, IndexedDB, and remote servers.
 - - meta
   - name: description
-    content: Learn how Data Persistence Adapters in SignalDB provide an abstraction layer over different storage systems like localStorage, IndexedDB, and remote servers.
+    content: Learn how Storage Adapters in SignalDB provide an abstraction layer over different storage systems like localStorage, IndexedDB, and remote servers.
 - - meta
   - name: keywords
-    content: data persistence, adapters, SignalDB, localStorage, IndexedDB, remote server, data storage, data retrieval, storage abstraction
+    content: data persistence, storage, adapters, SignalDB, localStorage, IndexedDB, remote server, data storage, data retrieval, storage abstraction
 ---
-# Data Persistence Adapters
+# Storage Adapters
 
-Persistence adapters in SignalDB provide the mechanism for storing and retrieving data, ensuring that your data is kept safe across sessions and reloads of your application.
+Storage adapters in SignalDB provide the mechanism for storing and retrieving data, ensuring that your data is kept safe across sessions and reloads of your application.
 
 These adapters interact with the underlying storage medium, such as localStorage, IndexedDB, or even a remote server, and handle the specifics of those storage systems while providing a consistent interface for data operations in your application.
 
-Persistence adapters are responsible for transforming the high-level operations you perform on your data (such as saving a document or loading a collection) into the low-level operations that the specific storage system can understand and perform.
+Storage adapters are responsible for transforming the high-level operations you perform on your data (such as saving a document or loading a collection) into the low-level operations that the specific storage system can understand and perform.
 
-The main benefit of using persistence adapters is the abstraction they provide. They allow SignalDB to remain agnostic to the underlying storage system. This means that you can switch between different systems without changing the rest of your code.
+The main benefit of using storage adapters is the abstraction they provide. They allow SignalDB to remain agnostic to the underlying storage system. This means that you can switch between different systems without changing the rest of your code.
 
-The follwing persistence adapters are currently available:
+The follwing storage adapters are currently available:
 
 - [IndexedDB](/reference/indexeddb/)
 - [localStorage](/reference/localstorage/)
 - [OPFS](/reference/opfs/)
 - [FileSystem](/reference/fs/)
 
-Building your own persistence adapter for your speicific use case is also possible and pretty straight forward.
-See [`createPersistenceAdapter`](/reference/core/createpersistenceadapter/) for more information.
+Building your own storage adapter for your speicific use case is also possible and pretty straight forward.
+See [`createStorageAdapter`](/reference/core/createstorageadapter/) for more information.

docs/reference/core/collection/index.md

@@ -69,7 +69,7 @@ Parameters
   * name: An optional name for the collection to make it easier to identify. This name will also be used in the developer tools.
   * memory: A [MemoryAdapter](/core-concepts/#memory-adapters) for storing items in memory.
   * reactivity: A [ReactivityAdapter](/reactivity/) for enabling reactivity.
-  * persistence: A [PersistenceAdapter](/data-persistence/) for enabling persistent storage.
+  * persistence: A [StorageAdapter](/data-persistence/) for enabling persistent storage.
   * transform: A transformation function to be applied to items. The document that should be transformed is passed as the only parameter. The function should return the transformed document (e.g. `(doc: T) => U`)
   * indices: An array of [IndexProvider](/reference/core/createindexprovider/) objects for creating indices on the collection.
   * primaryKeyGenerator: A function that generates a unique ID for the item. If not provided, a default generator will be used.