✨ First commit

Author: Nytyr

.gitignore

@@ -0,0 +1,39 @@
+# compiled output
+/dist
+/node_modules
+
+# Logs
+logs
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+lerna-debug.log*
+
+# OS
+.DS_Store
+
+# Tests
+/coverage
+/.nyc_output
+
+# IDEs and editors
+/.idea
+.project
+.classpath
+.c9/
+*.launch
+.settings/
+*.sublime-workspace
+
+# IDE - VSCode
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+
+# Project
+/.env
+
+dump.rdb

README.md

@@ -0,0 +1,137 @@
+Redisk
+=====
+[![npm version](https://badge.fury.io/js/redisj.svg)](https://badge.fury.io/js/redisk)
+
+Redisk is a TypeScript ORM library for Redis.
+
+
+## Features:
+
+* 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.
+
+
+## Getting started
+```bash
+npm install redisk --save
+```
+## Examples with a User model
+
+### Model definition
+```ts
+@Entity('user', { canBeListed: true })
+export class User {
+
+  @Primary()
+  @Property()
+  public readonly id: string;
+
+  @Property({sortable: false, searchable: true})
+  public readonly name: string;
+
+  @Unique()
+  @Property()
+  public readonly email: string;
+
+  @Index()
+  @Property()
+  public readonly color: string;
+
+  @Property({sortable: true, searchable: false})
+  public readonly created: Date;
+
+  constructor(
+      id: string,
+      name: string,
+      email: string,
+      color: string,
+      created: Date,
+    ) {
+      this.id = id;
+      this.name = name;
+      this.email = email;
+      this.color = color;
+      this.created = created;
+  }
+}
+```
+
+### Init Redisk
+
+```ts
+const redisk = new Redisk(new Metadata(), 'redis://127.0.0.1:6379/0');
+```
+
+### Store one user
+
+```ts
+await redisk.commit<User>(new User(id, name, email, color, created));
+```
+
+### Get one user by his primary key
+
+```ts
+await redisk.getOne<User>(User, id);
+```
+
+### Get one user by his email unique key 
+
+```ts
+await redisk.getOne<User>(User, '[email protected]', 'email');
+```
+
+### Count all users
+
+```ts
+await redisk.count<User>(User);
+```
+
+### List all users
+
+```ts
+await redisk.list<User>(User); // Returns an array of entities
+
+const limit = 10;
+const offset = 0;
+await redis.list<User>(User, limit, offset); // Returns 10 user entities
+
+await redisk.list<User>(User, undefined, undefined, {
+    field: 'created',
+    strategy: 'DESC',
+}); // Returns an array of entities sorted by his creation date in descending order
+```
+
+### Find all users by one index
+```ts
+const conditions = [
+    {
+        key: 'color',
+        value: 'red',
+    },
+];
+await redisk.find<User>(User, conditions, limit, offset); // Returns an array of entites that match the conditions
+```
+
+### Search users by his name
+
+```ts
+const condition = {
+    key: 'color',
+    value: 'red',
+};
+const maxNumberOfResults = 10;
+await redisk.search<User>(User, condition, maxNumberOfResults);
+```
+
+### Delete one user
+
+```ts
+await redisk.delete<User>(User, id);
+```

package-lock.json

@@ -0,0 +1,38 @@
+{
+  "name": "redisk",
+  "version": "1.0.0",
+  "description": "TypeScript ORM for Redis.",
+  "main": "index.js",
+  "directories": {
+    "test": "test"
+  },
+  "scripts": {
+    "prebuild": "rm -rf dist",
+    "build": "tsc -p tsconfig.json",
+    "prepublish:npm": "npm run build",
+    "publish:npm": "npm publish --access public",
+    "prepublish:next": "npm run build",
+    "publish:next": "npm publish --access public --tag next",
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "dependencies": {
+    "redis": "^2.8.0",
+    "bluebird": "^3.7.2",
+    "reflect-metadata": "^0.1.13"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ArkerLabs/redisk.git"
+  },
+  "keywords": [
+    "typescript",
+    "redis",
+    "orm"
+  ],
+  "author": "ArkerLabs",
+  "license": "ISC",
+  "bugs": {
+    "url": "https://github.com/ArkerLabs/redisk/issues"
+  },
+  "homepage": "https://github.com/ArkerLabs/redisk#readme"
+}

package.json

@@ -0,0 +1,12 @@
+import { MetadataStorage } from '../metadata/metadata.storage';
+
+export function Entity(name: string, options?: {canBeListed: boolean}) {
+    return (target: any) => {
+        let canBeListed = false;
+        if (options !== undefined && options.canBeListed === true) {
+            canBeListed = true;
+        }
+        MetadataStorage.getGlobal().canBeListed[target.name] = canBeListed;
+        MetadataStorage.getGlobal().names[target.name] = name;
+    };
+}

src/decorators/entity.decorator.ts

@@ -0,0 +1,11 @@
+import { MetadataStorage } from '../metadata/metadata.storage';
+
+// tslint:disable-next-line: ban-types
+export function Index(): Function {
+    return (object: object, propertyName: string) => {
+        if (MetadataStorage.getGlobal().indexes[object.constructor.name] === undefined) {
+            MetadataStorage.getGlobal().indexes[object.constructor.name] = [];
+        }
+        MetadataStorage.getGlobal().indexes[object.constructor.name].push(propertyName);
+    };
+}

src/decorators/index.decorator.ts

@@ -0,0 +1,8 @@
+import { MetadataStorage } from '../metadata/metadata.storage';
+
+// tslint:disable-next-line: ban-types
+export function Primary(): Function {
+    return (object: object, propertyName: string) => {
+        MetadataStorage.getGlobal().primary[object.constructor.name] = propertyName;
+    };
+}

src/decorators/primary.decorator.ts

@@ -0,0 +1,26 @@
+import { MetadataStorage } from '../metadata/metadata.storage';
+import 'reflect-metadata';
+
+export function Property(options: {sortable: boolean, searchable: boolean} = {
+    sortable: false,
+    searchable: false,
+// tslint:disable-next-line: ban-types
+}): Function {
+    return (object: object, propertyName: string) => {
+        const type = Reflect.getMetadata('design:type', object, propertyName).name;
+
+        if (options.sortable && (type !== 'Date' && type !== 'Number')) {
+            throw new Error('You can only make Dates and numbers sortables');
+        }
+
+        if (MetadataStorage.getGlobal().properties[object.constructor.name] === undefined) {
+            MetadataStorage.getGlobal().properties[object.constructor.name] = [];
+        }
+        MetadataStorage.getGlobal().properties[object.constructor.name].push({
+            name: propertyName,
+            sortable: options.sortable,
+            searchable: options.searchable,
+            type,
+        });
+    };
+}

src/decorators/property.decorator.ts

@@ -0,0 +1,11 @@
+import { MetadataStorage } from '../metadata/metadata.storage';
+
+// tslint:disable-next-line: ban-types
+export function Unique(): Function {
+    return (object: object, propertyName: string) => {
+        if (MetadataStorage.getGlobal().uniques[object.constructor.name] === undefined) {
+            MetadataStorage.getGlobal().uniques[object.constructor.name] = [];
+        }
+        MetadataStorage.getGlobal().uniques[object.constructor.name].push(propertyName);
+    };
+}

src/decorators/unique.decorator.ts

@@ -0,0 +1,4 @@
+export interface Condition {
+    key: string;
+    value: any;
+}

src/interfaces/condition.ts

@@ -0,0 +1,4 @@
+export interface OrderBy {
+    field: string;
+    strategy: 'ASC' | 'DESC';
+}

src/interfaces/orderby.ts

@@ -0,0 +1,10 @@
+import { PropertyMetadata } from './property.metadata';
+
+export interface EntityMetadata {
+    name: string;
+    primary: string;
+    indexes: string[];
+    uniques: string[];
+    properties: PropertyMetadata[];
+    canBeListed: boolean;
+}

src/metadata/entity.metadata.ts

@@ -0,0 +1,17 @@
+import { StateMetadata } from './state.metadata';
+
+export class MetadataStorage {
+
+    static global: StateMetadata = {
+        names: {},
+        canBeListed: {},
+        indexes: {},
+        uniques: {},
+        properties: {},
+        primary: {},
+    };
+
+    static getGlobal(): StateMetadata {
+        return MetadataStorage.global;
+    }
+}