TypeScript ORM for Redis.
npm install redisk

!Redisk CI
Redisk is a TypeScript ORM library for Redis.
* Store entities.
* Single relation support.
* Unique keys support.
* Retrieve entities by his primary keys or his unique keys.
* Indexes support.
* List entities with common filters, like limit, count and sort by.
* Find entities with multiple conditions ('>', '<', '=', '!=').
* Search (Similar to LIKE in SQL)
* And much more.
ts
const redisk = Redisk.init({url: 'redis://127.0.0.1:6379/0'});@Entity('user')
export class User {
@Primary()
@Property()
public readonly id: string;
@Property()
public name: string;
constructor(
id: string,
name: string,
) {
this.id = id;
this.name = name;
}
}
await redisk.save(new User('::id::', 'Foo'));
console.log(await redisk.getOne(User, '::id::'));
`
Installation
`bash
npm install redisk --save
`Contents
- Connection
- Options
- Models
- Model definition
- Entity
- Property
- Supported types
- Primary
- Unique
- Embedding other entities
- Queries
- Save
- Update
- Get by primary key
- Get by unique key
- Count
- List all
- List all with conditions
- Simple
- Multiple conditions
- Pattern matching
- Delete
- Logging
Connection
`ts
const redisk = Redisk.init(options);
`$3
| Property | Description |
|----------|-----------------------------------------------------------------------------------------------------------------------------------------|
| url | URL of the Redis server. Format [redis[s]:]//[[user][:password@]][host][:port][/db-number][?db=db-number[&password=bar[&option=value]]] |
| host | Host of the Redis server |
| port | Port of the Redis server |
| db | Number of the db (Default: 0) |
| password | Password of the Redis server
Closing connection to Redis:
`ts
await redisk.close();
`Models
$3
`ts
@Entity('user')
export class User { @Primary()
@Property()
public readonly id: string;
@Property({searchable: true})
public name: string;
@Unique()
@Property()
public email: string;
@Property({indexed: true})
public color: string;
@HasOne(type => Group, {cascadeInsert: true, cascadeUpdate: true})
@Property()
public group: Group;
@Property({indexed: true})
public created: Date;
constructor(
id: string,
name: string,
email: string,
color: string,
group: Group,
created: Date,
) {
this.id = id;
this.name = name;
this.email = email;
this.color = color;
this.group = group;
this.created = created;
}
}
`$3
Use the decorator Entity to convert your class into a Redisk entity.You can pass the option canBeListed to 'false' (Default is true) to save some space, but you will not be able to list user entities.
`ts
@Entity('user', { canBeListed: true })
export class User {
}
`$3
The decorator Property is used to save the fields into redis.Optionally, you can pass the options
indexed if you want to use the field to sort or to use as a condition in the 'list' method or searchable if you want to use pattern matching in this field.You can also set a default value.
Both options are false by default.
`ts
@Entity('user')
export class User { @Property({indexed: true, searchable: false, defaultValue: 'foo'})
public readonly created: Date;
}
`#### Supported types
Redisk support multiple types to store and query.
- String
- Date (Will be saved as a timestamp)
- Boolean
- Number
All other types will be converted to a string.
$3
Primary decorator is used to define the primary key of the entity. It can only be one primary key and his value must be unique for all the same entities.
`ts
@Entity('user')
export class User { @Primary()
@Property()
public readonly id: string;
}
`$3
This decorator is used to make the value of this field unique for all the same entities.
Then you can use it to query the entity.
`ts
@Entity('user')
export class User { @Unique()
@Property()
public readonly email: string;
}
`$3
You can make one to one relations with the HasOne decorator.Cascade inserts and updates are supported. (These options are false by default)
`ts
@Entity('user')
export class User { @HasOne(type => Group, {cascadeInsert: true, cascadeUpdate: true})
@Property()
public readonly group: Group;
}
`Queries
$3
`ts
await redisk.save(new User(id, name));
`$3
`ts
const user = await redisk.getOne(User, id);
user.name = 'Bar';
await redisk.save(user);
`
#### Note: Null fields will be removed from the persisted entity, undefined fields will not be modified from persisted entity.$3
`ts
await redisk.getOne(User, id);
`$3
`ts
const value = 'john@doe.com';
const uniqueKeyName = 'email';
await redisk.getOne(User, value, uniqueKeyName);
`$3
`ts
await redisk.count(User);
`$3
Returns an array of all user entities.
`ts
await redisk.list(User);
`Returns the first 10 user entities
`ts
const limit = 10;
const offset = 0;
await redis.list(User, limit, offset);
`Return an array of user entities sorted by his creation date in descending order
`ts
await redisk.list(User, undefined, undefined, undefined, {
field: 'created',
strategy: 'DESC',
});
`$3
#### Simple
Returns an array of users where his color is red`ts
const where =
conditions: [
{
key: 'color',
value: 'red',
comparator: '=',
},
],
type: 'AND',
};
await redisk.list(User, where, limit, offset);
`Returns an array of users where his creation date is greater than the day 23
`ts
const where =
conditions: [
{
key: 'created',
value: new Date('2020-02-23 00:00:00'),
comparator: '>',
},
],
type: 'AND',
};
await redisk.list(User, where, limit, offset);
`#### Multiple conditions
Returns an array of entities that his color field is 'red' or 'blue'.
Warning: Using multiple conditions leads to multiple queries with table intersections, to achieve high performance queries try to reduce the results with more concise conditional.
`ts
const where =
conditions: [
{
key: 'color',
value: 'red',
comparator: '=',
},
{
key: 'color',
value: 'blue',
comparator: '=',
},
],
type: 'OR',
};
await redisk.list(User, where, limit, offset);
`Returns an array of entities that his color field is 'red' and his food field is 'avocado'
`ts
const where =
conditions: [
{
key: 'color',
value: 'red',
comparator: '=',
},
{
key: 'food',
value: 'avocado',
comparator: '=',
},
],
type: 'AND',
};
await redisk.list(User, where, limit, offset);
`$3
You can search entities by properties marked as searchables.
`ts
const condition = {
key: 'name',
value: 'John',
};
const maxNumberOfResults = 10;
await redisk.search(User, condition, maxNumberOfResults);
`$3
`ts
await redisk.delete(User, id);
`Logging
We use winston for logging, if you want to see more info, like redis command that are being executed you can set process.env.REDISK_LOG_LEVEL to 'info'.
For example:
`bash
REDISK_LOG_LEVEL=info npm test
``