jsondocstore 0.1.0__tar.gz

jsondocstore-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Mirko Ortensi
+
+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.

jsondocstore-0.1.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: jsondocstore
+Version: 0.1.0
+Summary: Simple JSON document storage on disk
+Author-email: Mirko Ortensi <mirko.ortensi@gmail.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# JsonDocStore
+
+Simple JSON document storage on disk.
+
+Each document is stored as one file named `<key>.json`. The document key is the filename stem, not a field inside the JSON body.
+
+If you want to organize documents into different folders, use one `JsonDocStore` instance per folder. Each instance manages only the JSON files in its own directory.
+
+## What It Does
+
+- Stores one JSON document per file.
+- Reads documents directly by filename.
+- Uses optional in-memory indexes defined in `index.json`.
+- Provides an interactive CLI in `cli.py`.
+
+## Data Model
+
+- `get(key)` reads `<key>.json`.
+- `insert(key, doc)` writes `<key>.json`.
+- Valid keys may contain letters, digits, `.`, `_`, and `-`. No whitespace.
+
+## Schema
+
+`index.json` is optional.
+
+- `create=True` creates the directory if needed. It does not create `index.json`.
+- `index_fields` defines which fields are indexed in memory.
+- `get()`, `insert()`, `delete()`, and `list_all()` work without `index.json`.
+- `query_by()` only works when an index exists. Querying without an index, or on a non-indexed field, raises an error.
+- Indexes work only on top-level document fields, not nested paths.
+
+Example:
+
+```json
+{
+  "index_fields": ["email", "status"]
+}
+```
+
+For example, this works:
+
+```json
+{
+  "email": "alice@example.com",
+  "profile": {
+    "city": "Rome"
+  }
+}
+```
+
+- you can index `email`
+- you cannot index `profile.city`
+
+## CLI
+
+Start the interactive shell:
+
+```bash
+jsondocstore /path/to/store
+```
+
+Commands:
+
+- `list` prints document filenames only
+- `listindexes` prints indexed fields, or `[]` if there is no `index.json`
+- `queryby FIELD VALUE`
+- `createindex FIELD`
+- `deleteindex FIELD`
+- `insert KEY JSON_DOCUMENT`
+- `update KEY JSON_DOCUMENT`
+- `delete KEY`
+- `exit`
+
+Example session:
+
+```text
+$ jsondocstore ./data
+jsondocstore> insert user-1 '{"username": "alice", "password": "secret1", "role": "admin"}'
+jsondocstore> insert user-2 '{"username": "bob", "password": "secret2", "role": "user"}'
+jsondocstore> insert user-3 '{"username": "carol", "password": "secret3", "role": "user"}'
+jsondocstore> update user-2 '{"username": "bob", "password": "secret2", "role": "admin"}'
+jsondocstore> list
+[
+  "user-1.json",
+  "user-2.json",
+  "user-3.json"
+]
+jsondocstore> createindex role
+jsondocstore> queryby role user
+[
+  {
+    "password": "secret2",
+    "role": "user",
+    "username": "bob"
+  },
+  {
+    "password": "secret3",
+    "role": "user",
+    "username": "carol"
+  }
+]
+```
+
+## Library
+
+```python
+from jsondocstore import JsonDocStore
+
+store = JsonDocStore("./data", create=True)
+store.insert("user-1", {"username": "alice", "password": "secret1", "role": "admin"})
+store.insert("user-2", {"username": "bob", "password": "secret2", "role": "user"})
+store.insert("user-3", {"username": "carol", "password": "secret3", "role": "user"})
+store.update("user-2", {"username": "bob", "password": "secret2", "role": "admin"})
+names = store.list_all()
+store.create_index("role")
+admins = store.query_by("role", "admin")
+doc = store.get("user-1")
+```

jsondocstore-0.1.0/README.md

@@ -0,0 +1,118 @@
+# JsonDocStore
+
+Simple JSON document storage on disk.
+
+Each document is stored as one file named `<key>.json`. The document key is the filename stem, not a field inside the JSON body.
+
+If you want to organize documents into different folders, use one `JsonDocStore` instance per folder. Each instance manages only the JSON files in its own directory.
+
+## What It Does
+
+- Stores one JSON document per file.
+- Reads documents directly by filename.
+- Uses optional in-memory indexes defined in `index.json`.
+- Provides an interactive CLI in `cli.py`.
+
+## Data Model
+
+- `get(key)` reads `<key>.json`.
+- `insert(key, doc)` writes `<key>.json`.
+- Valid keys may contain letters, digits, `.`, `_`, and `-`. No whitespace.
+
+## Schema
+
+`index.json` is optional.
+
+- `create=True` creates the directory if needed. It does not create `index.json`.
+- `index_fields` defines which fields are indexed in memory.
+- `get()`, `insert()`, `delete()`, and `list_all()` work without `index.json`.
+- `query_by()` only works when an index exists. Querying without an index, or on a non-indexed field, raises an error.
+- Indexes work only on top-level document fields, not nested paths.
+
+Example:
+
+```json
+{
+  "index_fields": ["email", "status"]
+}
+```
+
+For example, this works:
+
+```json
+{
+  "email": "alice@example.com",
+  "profile": {
+    "city": "Rome"
+  }
+}
+```
+
+- you can index `email`
+- you cannot index `profile.city`
+
+## CLI
+
+Start the interactive shell:
+
+```bash
+jsondocstore /path/to/store
+```
+
+Commands:
+
+- `list` prints document filenames only
+- `listindexes` prints indexed fields, or `[]` if there is no `index.json`
+- `queryby FIELD VALUE`
+- `createindex FIELD`
+- `deleteindex FIELD`
+- `insert KEY JSON_DOCUMENT`
+- `update KEY JSON_DOCUMENT`
+- `delete KEY`
+- `exit`
+
+Example session:
+
+```text
+$ jsondocstore ./data
+jsondocstore> insert user-1 '{"username": "alice", "password": "secret1", "role": "admin"}'
+jsondocstore> insert user-2 '{"username": "bob", "password": "secret2", "role": "user"}'
+jsondocstore> insert user-3 '{"username": "carol", "password": "secret3", "role": "user"}'
+jsondocstore> update user-2 '{"username": "bob", "password": "secret2", "role": "admin"}'
+jsondocstore> list
+[
+  "user-1.json",
+  "user-2.json",
+  "user-3.json"
+]
+jsondocstore> createindex role
+jsondocstore> queryby role user
+[
+  {
+    "password": "secret2",
+    "role": "user",
+    "username": "bob"
+  },
+  {
+    "password": "secret3",
+    "role": "user",
+    "username": "carol"
+  }
+]
+```
+
+## Library
+
+```python
+from jsondocstore import JsonDocStore
+
+store = JsonDocStore("./data", create=True)
+store.insert("user-1", {"username": "alice", "password": "secret1", "role": "admin"})
+store.insert("user-2", {"username": "bob", "password": "secret2", "role": "user"})
+store.insert("user-3", {"username": "carol", "password": "secret3", "role": "user"})
+store.update("user-2", {"username": "bob", "password": "secret2", "role": "admin"})
+names = store.list_all()
+store.create_index("role")
+admins = store.query_by("role", "admin")
+doc = store.get("user-1")
+```

jsondocstore-0.1.0/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jsondocstore"
+version = "0.1.0"
+description = "Simple JSON document storage on disk"
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [
+  { name = "Mirko Ortensi", email = "mirko.ortensi@gmail.com" },
+]
+
+[project.scripts]
+jsondocstore = "jsondocstore.cli:main"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

jsondocstore-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

jsondocstore-0.1.0/src/jsondocstore/__init__.py

@@ -0,0 +1,3 @@
+from .core import JsonDocStore
+
+__all__ = ["JsonDocStore"]

jsondocstore-0.1.0/src/jsondocstore/cli.py

@@ -0,0 +1,239 @@
+from __future__ import annotations
+
+import cmd
+import json
+import shlex
+import sys
+from pathlib import Path
+
+try:
+    import readline  # noqa: F401
+except ImportError:
+    readline = None
+
+from .core import JsonDocStore, _json_dump
+
+
+def _parse_query_value(text: str):
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return text
+
+
+def _configure_readline() -> None:
+    if readline is None:
+        return
+    doc = getattr(readline, "__doc__", "") or ""
+    if "libedit" in doc:
+        readline.parse_and_bind("bind ^I rl_complete")
+    else:
+        readline.parse_and_bind("tab: complete")
+
+
+class JsonDocStoreShell(cmd.Cmd):
+    intro = "JsonDocStore interactive shell. Type 'help' for commands."
+    prompt = "jsondocstore> "
+
+    def __init__(self, store: JsonDocStore):
+        super().__init__()
+        self.store = store
+
+    def get_names(self):
+        return [name for name in super().get_names() if name != "do_EOF"]
+
+    def emptyline(self):
+        return None
+
+    def _print_json(self, value):
+        print(_json_dump(value))
+
+    def _complete_from_options(self, text, options):
+        return sorted(option for option in options if option.startswith(text))
+
+    def _document_keys(self):
+        root = getattr(self.store, "root", None)
+        if root is None:
+            return []
+        return sorted(
+            path.stem
+            for path in Path(root).glob("*.json")
+            if path.name != "index.json"
+        )
+
+    def _document_fields(self):
+        fields = set()
+        root = getattr(self.store, "root", None)
+        if root is None:
+            return []
+        for path in Path(root).glob("*.json"):
+            if path.name == "index.json":
+                continue
+            try:
+                doc = json.loads(path.read_text(encoding="utf-8"))
+                fields.update(doc.keys())
+            except Exception:
+                continue
+        return sorted(field for field in fields if isinstance(field, str))
+
+    def _query_fields(self):
+        try:
+            indexes = self.store.list_indexes()
+        except Exception:
+            return []
+        return indexes or self._document_fields()
+
+    def complete_queryby(self, text, line, begidx, endidx):
+        args = shlex.split(line[:begidx])
+        if len(args) <= 1:
+            return self._complete_from_options(text, self._query_fields())
+        return []
+
+    def complete_createindex(self, text, line, begidx, endidx):
+        indexed = set(self.store.list_indexes())
+        fields = [field for field in self._document_fields() if field not in indexed]
+        return self._complete_from_options(text, fields)
+
+    def complete_deleteindex(self, text, line, begidx, endidx):
+        return self._complete_from_options(text, self.store.list_indexes())
+
+    def complete_delete(self, text, line, begidx, endidx):
+        return self._complete_from_options(text, self._document_keys())
+
+    def do_list(self, arg):
+        """List all documents."""
+        self._print_json(self.store.list_all())
+
+    def do_listindexes(self, arg):
+        """List indexed fields."""
+        self._print_json(self.store.list_indexes())
+
+    def do_queryby(self, arg):
+        """queryby FIELD VALUE"""
+        try:
+            field, value = shlex.split(arg)
+        except ValueError:
+            print("Usage: queryby FIELD VALUE")
+            return
+
+        try:
+            self._print_json(self.store.query_by(field, _parse_query_value(value)))
+        except Exception as e:
+            print(f"Error: {e}")
+
+    def do_createindex(self, arg):
+        """createindex FIELD"""
+        field = arg.strip()
+        if not field:
+            print("Usage: createindex FIELD")
+            return
+
+        try:
+            self.store.create_index(field)
+            print(f"Created index {field}")
+        except Exception as e:
+            print(f"Error: {e}")
+
+    def do_deleteindex(self, arg):
+        """deleteindex FIELD"""
+        field = arg.strip()
+        if not field:
+            print("Usage: deleteindex FIELD")
+            return
+
+        try:
+            deleted = self.store.delete_index(field)
+            if deleted:
+                print(f"Deleted index {field}")
+            else:
+                print(f"Index not found: {field}")
+        except Exception as e:
+            print(f"Error: {e}")
+
+    def do_insert(self, arg):
+        """insert KEY JSON_DOCUMENT"""
+        if not arg.strip():
+            print("Usage: insert KEY JSON_DOCUMENT")
+            return
+
+        try:
+            parts = shlex.split(arg)
+            if len(parts) < 2:
+                raise ValueError
+            key = parts[0]
+            json_text = " ".join(parts[1:])
+        except ValueError:
+            print("Usage: insert KEY JSON_DOCUMENT")
+            return
+
+        try:
+            self._print_json(self.store.insert(key, json.loads(json_text)))
+        except Exception as e:
+            print(f"Error: {e}")
+
+    def do_update(self, arg):
+        """update KEY JSON_DOCUMENT"""
+        if not arg.strip():
+            print("Usage: update KEY JSON_DOCUMENT")
+            return
+
+        try:
+            parts = shlex.split(arg)
+            if len(parts) < 2:
+                raise ValueError
+            key = parts[0]
+            json_text = " ".join(parts[1:])
+        except ValueError:
+            print("Usage: update KEY JSON_DOCUMENT")
+            return
+
+        try:
+            self._print_json(self.store.update(key, json.loads(json_text)))
+        except Exception as e:
+            print(f"Error: {e}")
+
+    def do_delete(self, arg):
+        """delete PK"""
+        pk = arg.strip()
+        if not pk:
+            print("Usage: delete PK")
+            return
+
+        try:
+            self.store.delete(pk)
+            print(f"Deleted {pk}")
+        except Exception as e:
+            print(f"Error: {e}")
+
+    def do_exit(self, arg):
+        """Exit the shell."""
+        return True
+
+    def do_EOF(self, arg):
+        """Exit on Ctrl-D."""
+        print()
+        return True
+
+
+def main():
+    if len(sys.argv) != 2:
+        print("Usage: python -m jsondocstore /path/to/db", file=sys.stderr)
+        return 1
+
+    _configure_readline()
+    root = Path(sys.argv[1])
+    try:
+        store = JsonDocStore(root, create=True)
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+    try:
+        JsonDocStoreShell(store).cmdloop()
+    except KeyboardInterrupt:
+        print()
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

jsondocstore-0.1.0/src/jsondocstore/core.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+from collections import defaultdict
+from pathlib import Path
+import json
+import re
+import tempfile
+from typing import Any
+
+
+def _json_dump(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, indent=2, sort_keys=True)
+
+
+_VALID_KEY_RE = re.compile(r"^[A-Za-z0-9._-]+$")
+
+
+class JsonDocStore:
+    def __init__(self, root: str | Path, create: bool = False):
+        self.root = Path(root)
+        if create:
+            self.root.mkdir(parents=True, exist_ok=True)
+        elif not self.root.exists():
+            raise ValueError(f"Directory does not exist: {self.root}")
+        if not self.root.is_dir():
+            raise ValueError(f"Path is not a directory: {self.root}")
+
+        self.schema_path = self.root / "index.json"
+        self.schema = self._load_schema() if self.schema_path.exists() else None
+        self.index_fields = list(self.schema.get("index_fields", [])) if self.schema else []
+        self.indexes: dict[str, dict[Any, set[str]]] = {field: defaultdict(set) for field in self.index_fields}
+        if self.schema is not None:
+            self._rebuild_index()
+
+    def _load_schema(self) -> dict[str, Any]:
+        schema = json.loads(self.schema_path.read_text(encoding="utf-8"))
+        if "index_fields" not in schema:
+            raise ValueError("index.json must contain 'index_fields'")
+        if not isinstance(schema["index_fields"], list):
+            raise ValueError("'index_fields' must be a list")
+        if not all(isinstance(field, str) for field in schema["index_fields"]):
+            raise ValueError("'index_fields' entries must be strings")
+        return schema
+
+    def _doc_path(self, pk: str) -> Path:
+        return self.root / f"{pk}.json"
+
+    def _validate_key(self, pk: str) -> None:
+        if not pk:
+            raise ValueError("Document key must not be empty")
+        if pk in {".", ".."}:
+            raise ValueError(f"Invalid document key: {pk}")
+        if pk == "index":
+            raise ValueError("Document key 'index' is reserved")
+        if not _VALID_KEY_RE.fullmatch(pk):
+            raise ValueError(
+                "Invalid document key. Use only letters, digits, dot, underscore, or hyphen"
+            )
+
+    def _rebuild_index(self) -> None:
+        for field in self.index_fields:
+            self.indexes[field].clear()
+        for path in sorted(self.root.glob("*.json")):
+            if path.name == "index.json":
+                continue
+            doc = json.loads(path.read_text(encoding="utf-8"))
+            self._add_indexes(path.stem, doc)
+
+    def _list_doc_names(self) -> list[str]:
+        return [
+            path.name
+            for path in sorted(self.root.glob("*.json"))
+            if path.name != "index.json"
+        ]
+
+    def _add_indexes(self, pk: str, doc: dict[str, Any]) -> None:
+        for field in self.index_fields:
+            if field in doc:
+                self.indexes[field][doc[field]].add(pk)
+
+    def _remove_indexes(self, pk: str, doc: dict[str, Any]) -> None:
+        for field in self.index_fields:
+            if field in doc:
+                value = doc[field]
+                bucket = self.indexes[field].get(value)
+                if bucket is not None:
+                    bucket.discard(pk)
+                    if not bucket:
+                        del self.indexes[field][value]
+
+    def _write_json_atomic(self, path: Path, obj: dict[str, Any]) -> None:
+        with tempfile.NamedTemporaryFile(
+            "w", encoding="utf-8", dir=str(self.root), delete=False
+        ) as tmp:
+            tmp.write(_json_dump(obj))
+            tmp_path = Path(tmp.name)
+        tmp_path.replace(path)
+
+    def list_all(self) -> list[str]:
+        return self._list_doc_names()
+
+    def get(self, pk: str) -> dict[str, Any]:
+        self._validate_key(pk)
+        path = self._doc_path(pk)
+        if not path.exists():
+            raise KeyError(f"Document not found: {pk}")
+        return json.loads(path.read_text(encoding="utf-8"))
+
+    def query_by(self, field: str, value: Any) -> list[dict[str, Any]]:
+        if self.schema is None:
+            raise ValueError("Cannot query without an index. Create an index first")
+        if field not in self.indexes:
+            raise ValueError(f"Field is not indexed: {field}")
+        return [self.get(pk) for pk in sorted(self.indexes[field].get(value, ()))]
+
+    def create_index(self, field: str) -> None:
+        if self.schema is None:
+            self.schema = {"index_fields": []}
+            self.index_fields = []
+            self.indexes = {}
+        if field in self.indexes:
+            raise ValueError(f"Index already exists: {field}. Delete it before recreating")
+        self.index_fields.append(field)
+        self.indexes[field] = defaultdict(set)
+        self.schema["index_fields"] = list(self.index_fields)
+        self._write_json_atomic(self.schema_path, self.schema)
+        self._rebuild_index()
+
+    def list_indexes(self) -> list[str]:
+        return sorted(self.index_fields)
+
+    def delete_index(self, field: str) -> bool:
+        if self.schema is None:
+            raise ValueError("Cannot delete an index without an index.json")
+        if field not in self.indexes:
+            return False
+        self.index_fields = [name for name in self.index_fields if name != field]
+        del self.indexes[field]
+        self.schema["index_fields"] = list(self.index_fields)
+        self._write_json_atomic(self.schema_path, self.schema)
+        return True
+
+    def insert(self, pk: str, doc: dict[str, Any]) -> dict[str, Any]:
+        self._validate_key(pk)
+        path = self._doc_path(pk)
+        if path.exists():
+            raise ValueError(f"Primary key already exists: {pk}")
+        if self.schema is not None:
+            self._add_indexes(pk, doc)
+        self._write_json_atomic(path, doc)
+        return doc
+
+    def update(self, pk: str, doc: dict[str, Any]) -> dict[str, Any]:
+        self._validate_key(pk)
+        path = self._doc_path(pk)
+        if not path.exists():
+            raise KeyError(f"Document not found: {pk}")
+        if self.schema is not None:
+            old_doc = self.get(pk)
+            self._remove_indexes(pk, old_doc)
+            self._add_indexes(pk, doc)
+        self._write_json_atomic(path, doc)
+        return doc
+
+    def delete(self, pk: str) -> None:
+        self._validate_key(pk)
+        path = self._doc_path(pk)
+        if not path.exists():
+            raise KeyError(f"Document not found: {pk}")
+        if self.schema is not None:
+            doc = self.get(pk)
+            self._remove_indexes(pk, doc)
+        path.unlink()

jsondocstore-0.1.0/src/jsondocstore.egg-info/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: jsondocstore
+Version: 0.1.0
+Summary: Simple JSON document storage on disk
+Author-email: Mirko Ortensi <mirko.ortensi@gmail.com>
+License: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# JsonDocStore
+
+Simple JSON document storage on disk.
+
+Each document is stored as one file named `<key>.json`. The document key is the filename stem, not a field inside the JSON body.
+
+If you want to organize documents into different folders, use one `JsonDocStore` instance per folder. Each instance manages only the JSON files in its own directory.
+
+## What It Does
+
+- Stores one JSON document per file.
+- Reads documents directly by filename.
+- Uses optional in-memory indexes defined in `index.json`.
+- Provides an interactive CLI in `cli.py`.
+
+## Data Model
+
+- `get(key)` reads `<key>.json`.
+- `insert(key, doc)` writes `<key>.json`.
+- Valid keys may contain letters, digits, `.`, `_`, and `-`. No whitespace.
+
+## Schema
+
+`index.json` is optional.
+
+- `create=True` creates the directory if needed. It does not create `index.json`.
+- `index_fields` defines which fields are indexed in memory.
+- `get()`, `insert()`, `delete()`, and `list_all()` work without `index.json`.
+- `query_by()` only works when an index exists. Querying without an index, or on a non-indexed field, raises an error.
+- Indexes work only on top-level document fields, not nested paths.
+
+Example:
+
+```json
+{
+  "index_fields": ["email", "status"]
+}
+```
+
+For example, this works:
+
+```json
+{
+  "email": "alice@example.com",
+  "profile": {
+    "city": "Rome"
+  }
+}
+```
+
+- you can index `email`
+- you cannot index `profile.city`
+
+## CLI
+
+Start the interactive shell:
+
+```bash
+jsondocstore /path/to/store
+```
+
+Commands:
+
+- `list` prints document filenames only
+- `listindexes` prints indexed fields, or `[]` if there is no `index.json`
+- `queryby FIELD VALUE`
+- `createindex FIELD`
+- `deleteindex FIELD`
+- `insert KEY JSON_DOCUMENT`
+- `update KEY JSON_DOCUMENT`
+- `delete KEY`
+- `exit`
+
+Example session:
+
+```text
+$ jsondocstore ./data
+jsondocstore> insert user-1 '{"username": "alice", "password": "secret1", "role": "admin"}'
+jsondocstore> insert user-2 '{"username": "bob", "password": "secret2", "role": "user"}'
+jsondocstore> insert user-3 '{"username": "carol", "password": "secret3", "role": "user"}'
+jsondocstore> update user-2 '{"username": "bob", "password": "secret2", "role": "admin"}'
+jsondocstore> list
+[
+  "user-1.json",
+  "user-2.json",
+  "user-3.json"
+]
+jsondocstore> createindex role
+jsondocstore> queryby role user
+[
+  {
+    "password": "secret2",
+    "role": "user",
+    "username": "bob"
+  },
+  {
+    "password": "secret3",
+    "role": "user",
+    "username": "carol"
+  }
+]
+```
+
+## Library
+
+```python
+from jsondocstore import JsonDocStore
+
+store = JsonDocStore("./data", create=True)
+store.insert("user-1", {"username": "alice", "password": "secret1", "role": "admin"})
+store.insert("user-2", {"username": "bob", "password": "secret2", "role": "user"})
+store.insert("user-3", {"username": "carol", "password": "secret3", "role": "user"})
+store.update("user-2", {"username": "bob", "password": "secret2", "role": "admin"})
+names = store.list_all()
+store.create_index("role")
+admins = store.query_by("role", "admin")
+doc = store.get("user-1")
+```

jsondocstore-0.1.0/src/jsondocstore.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+src/jsondocstore/__init__.py
+src/jsondocstore/cli.py
+src/jsondocstore/core.py
+src/jsondocstore.egg-info/PKG-INFO
+src/jsondocstore.egg-info/SOURCES.txt
+src/jsondocstore.egg-info/dependency_links.txt
+src/jsondocstore.egg-info/entry_points.txt
+src/jsondocstore.egg-info/top_level.txt

jsondocstore-0.1.0/src/jsondocstore.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jsondocstore-0.1.0/src/jsondocstore.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+jsondocstore = jsondocstore.cli:main

jsondocstore-0.1.0/src/jsondocstore.egg-info/top_level.txt

@@ -0,0 +1 @@
+jsondocstore