Ecosyste.ms: Awesome
An open API service indexing awesome lists of open source software.
https://github.com/samuelscheit/lambert-orm
A Database abstraction layer for different DB Engines
https://github.com/samuelscheit/lambert-orm
abstraction database mongodb orm
Last synced: 13 days ago
JSON representation
A Database abstraction layer for different DB Engines
- Host: GitHub
- URL: https://github.com/samuelscheit/lambert-orm
- Owner: SamuelScheit
- License: mit
- Created: 2020-12-17T09:30:09.000Z (almost 4 years ago)
- Default Branch: master
- Last Pushed: 2023-07-19T11:10:27.000Z (over 1 year ago)
- Last Synced: 2024-05-01T19:33:55.833Z (7 months ago)
- Topics: abstraction, database, mongodb, orm
- Language: TypeScript
- Homepage:
- Size: 497 KB
- Stars: 2
- Watchers: 0
- Forks: 0
- Open Issues: 0
-
Metadata Files:
- Readme: README.md
- License: LICENSE
Awesome Lists containing this project
README
# Lambert-db
A Database abstraction layer for different DB Engines
This allows easy access to a database much like like accessing an object.
The library design facilitates exchanging the underlying database engine without changing your application code.
Also it only get's/set's the necessary data for the operations and not the whole table unlike quick.db.
## Installation
```
npm i lambert-db
# or "yarn add lambert-db"
```
## Usage
ES5 import
```js
require("lambert-db");
```
or ES6 import
```js
import "lambert-db";
```
## Database
Choose a database engine: ``MongoDatabase``
At the moment there is only an implementation for MongoDB available, however I will add others.
You can also implement your own database class and submit a pull request.
Every Database has an ``.init()`` method whose execution must be awaited before using the database.
```ts
class Database {
init (): Promise;
destroy(): Promise;
data : DatastoreInterface; // ES6 Proxy Object
}
```
To use the database, access the ``.data`` property and specify the path.
#### Example
```js
db.data.users.name // (the path for this example is users.name).
```
The below operations can then be called on the path:
## Operations
```ts
get(projection?: Projection): Promise; // returns a promise with the value for this path
first() : Promise; // returns a promise with the first entry
last() : Promise; // returns a promise with the last entry
random() : Promise; // returns a promise with a random entry
delete() : Promise; // deletes the value for this path
set(value: any) : Promise; // sets the value for this path
exists() : Promise; // checks if a value for this path exists
push(value: any) : Promise; // pushes the value into the array for this path
```
All operations are asynchronous and return a [promise](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Promise) which have to be awaited.
The return value of type ``Promise`` indicates a successful operation.
#### Example
```js
await db.data.users.push({id: 1, name: "test", posts: [1,2,3] }) // this will insert this user object
await db.data.users.name.set("hello") // this will set the name hello for all users
await db.data.users.name.get() // this will return an array with the users names
await db.data.users.delete() // this will delete all users
```
### Projection
The ``.get(projection?: Projection)`` function can optionally accept a projection parameter.
A Projection is a Key-Value Object of booleans that indicates whether these properties should be received.
```ts
type Projection = {
[index: string]: boolean;
};
var projection = { id: true, name: true}
```
For example, a database with a ``boards`` table that contains board objects like: ``{ id: number, name: string, members: [], posts: [] }`` and only ids and names should be accessed.
The projection parameters can be used to specify multiple but not all properties to be retrieved e.g:
```js
await db.data.boards.get({ id: true, name: true}); // This will only return the id and name of the boards
```
### Filter sub arrays
Filters can be used to get a specific card in the example above, by calling a property with ``.property(filter)`` when accessing a path.
A filter can be an object or a function which will be called for every entry in an array and can be specified for each property in a path.
#### Example:
```js
await db.data.boards({id: 1}).get() // This will return the board with id: 1 and insert
await db.data.boards({id: 1}).posts({id: 0}).comments.push({author: 1, content: "test"}) // This will post a comment to board.id: 1 and post.id: 0
```
## Full Example
```js
const { MongoDatabase } = require("lambert-db");
const db: Database = new MongoDatabase();
db.init().then(async () => {
let success = await db.data.users.push({ id: 0, roles: [] });
if (!success) throw new Error("couldn't insert new user");
let user = await db.data.users({ id: 0 }).get();
console.log(user);
success = await db.data.users({ id: 0 }).roles.push({ type: "admin", name: "test", permissions: 2 });
if (!success) throw new Error("couldn't add role for user");
console.log(await db.data.users.get({ id: true}));
success = await db.data.users({ id: 1 }).delete();
if (!success) throw new Error("couldn't delete user");
});
```