@gapi/sequelize 1.8.122

package/.prettierrc

@@ -0,0 +1,4 @@
+{
+    "singleQuote": true,
+    "printWidth": 80
+}

package/README.md

@@ -0,0 +1,189 @@
+# @Gapi/Sequelize
+
+<!-- ![Build Status](http://gitlab.youvolio.com/gapi/gapi/badges/branch/build.svg) -->
+
+#### @Gapi Sequelize module @StrongTyped
+
+##### For questions/issues you can write ticket [here](http://gitlab.youvolio.com/gapi/gapi-sequelize/issues)
+##### This module is intended to be used with [GAPI](https://github.com/Stradivario/gapi)
+
+## Installation and basic examples:
+##### To install this Gapi module, run:
+
+```bash
+$ npm install @gapi/sequelize --save
+```
+
+## Consuming gapi-sequelize
+
+##### Import inside AppModule or CoreModule
+```typescript
+
+import { Module } from '@rxdi/core';
+import { SequelizeModule } from '@gapi/sequelize';
+
+@Module({
+    imports: [
+        SequelizeModule.forRoot({
+            dialect: 'postgres',
+            host: process.env.DB_HOST || '',
+            port: process.env.DB_PORT || 5432,
+            username: process.env.DB_USERNAME || '',
+            password: process.env.DB_PASSWORD || '',
+            database: process.env.DB_NAME || 'your-database',
+            storage: ':memory:',
+            logging: false,
+            modelPaths: [process.cwd() + '/src/models'],
+            force: false
+        })
+    ]
+})
+export class CoreModule { }
+```
+
+##### Create folder root/src/models and put this testing User Typescript-Sequelize Model with Uppercase name example: "User.ts"
+```typescript
+
+import {
+    Table,
+    Column,
+    Model,
+    CreatedAt,
+    UpdatedAt,
+    DeletedAt,
+    PrimaryKey,
+    AutoIncrement,
+    HasMany,
+    DataType,
+    BelongsToMany
+} from 'sequelize-typescript';
+
+export interface UserSettings {
+    sidebar: boolean;
+}
+
+@Table
+export class User extends Model<User> {
+
+    @PrimaryKey
+    @AutoIncrement
+    @Column
+    id: number;
+
+    @Column
+    name: string;
+
+    @Column({
+        type: DataType.ENUM({ values: ['ADMIN', 'USER'] })
+    })
+    type: 'ADMIN' | 'USER';
+
+    @Column({
+        type: DataType.JSONB,
+        allowNull: true
+    })
+    settings: UserSettings;
+
+
+    @CreatedAt
+    creationDate: Date;
+
+    @UpdatedAt
+    updatedOn: Date;
+
+    @DeletedAt
+    deletionDate: Date;
+
+}
+
+```
+
+##### Final use this class inside your services the following way
+
+```typescript
+import { Service } from "@rxdi/core";
+import { UserType } from "../types/user.type";
+import { User } from '../../../models/User';
+
+@Service()
+export class AnotherService {
+    trimFirstLetter(username: string): string {
+        return username.charAt(1);
+    }
+}
+
+@Service()
+export class UserService {
+    constructor(
+        private anotherService: AnotherService
+    ) { }
+
+    async findUser(id: number): Promise<User> {
+        return await User.findOne({ where: { id: id } });
+    }
+
+    async addUser(user: User): Promise<User> {
+        return await User.create(user);
+    }
+
+    async deleteUser(id: number) {
+        return await User.destroy({ where: { id: id } });
+    }
+
+    async updateUser(user: User) {
+        return await User.update(user, {
+            where: {
+                id: user.id
+            }
+        })
+    }
+
+}
+
+```
+
+#### Advanced getting sequelize instance to manage your sequelize connection
+
+```typescript 
+import { Service } from '@rxdi/core';
+import { SequelizeService } from '@gapi/sequelize';
+
+@Service()
+export class SequelizePrivateService extends SequelizeService implements SequelizeService {
+    sequelize: Sequelize;
+    constructor() {
+        super({
+            dialect: 'postgres',
+            host: process.env.DB_HOST || '',
+            port: process.env.DB_PORT || '5432',
+            username: process.env.DB_USERNAME || '',
+            password: process.env.DB_PASSWORD || '',
+            name: process.env.DB_NAME || 'your-database',
+            storage: ':memory:',
+            logging: false,
+            modelPaths: [process.cwd() + '/src/models'],
+            force: false
+        })
+    }
+}
+
+```
+
+#### Next import SequelizePrivateService inside Core or AppModule
+
+```typescript
+import { Module } from '@rxdi/core';
+import { SequelizeModule } from '@gapi/sequelize';
+import { SequelizePrivateService } from './services/sequelize/sequelize.service.ts';
+
+@Module({
+    services: [SequelizePrivateService]
+})
+export class CoreModule { }
+
+```
+
+
+TODO: Better documentation...
+
+Enjoy ! :)

package/dist/index.d.ts

@@ -0,0 +1,7 @@
+import { ModuleWithServices } from '@rxdi/core';
+import { SequelizeConfig } from './sequelize.interface';
+export declare class SequelizeModule {
+    static forRoot(config: SequelizeConfig): ModuleWithServices;
+}
+export * from './sequelize.interface';
+export * from './sequelize-config.service';

package/dist/index.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var SequelizeModule_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequelizeModule = void 0;
+const core_1 = require("@rxdi/core");
+const sequelize_typescript_1 = require("sequelize-typescript");
+const sequelize_config_service_1 = require("./sequelize-config.service");
+let SequelizeModule = SequelizeModule_1 = class SequelizeModule {
+    static forRoot(config) {
+        return {
+            module: SequelizeModule_1,
+            services: [
+                {
+                    provide: sequelize_config_service_1.SEQUELIZE,
+                    lazy: true,
+                    useFactory: () => __awaiter(this, void 0, void 0, function* () {
+                        const sequelize = new sequelize_typescript_1.Sequelize(config);
+                        sequelize.addModels(config.models ? config.models : []);
+                        yield sequelize.sync(config);
+                        return sequelize;
+                    }),
+                },
+            ],
+        };
+    }
+};
+SequelizeModule = SequelizeModule_1 = __decorate([
+    core_1.Module()
+], SequelizeModule);
+exports.SequelizeModule = SequelizeModule;
+__exportStar(require("./sequelize.interface"), exports);
+__exportStar(require("./sequelize-config.service"), exports);

package/dist/sequelize-config.service.d.ts

@@ -0,0 +1,2 @@
+import { InjectionToken } from '@rxdi/core';
+export declare const SEQUELIZE: InjectionToken<unknown>;

package/dist/sequelize-config.service.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEQUELIZE = void 0;
+const core_1 = require("@rxdi/core");
+exports.SEQUELIZE = new core_1.InjectionToken('gapi-sequelize-config-token');

package/dist/sequelize.interface.d.ts

@@ -0,0 +1,18 @@
+import { SequelizeOptions } from 'sequelize-typescript';
+import { Dialect } from 'sequelize/types';
+export declare class SequelizeConfig implements SequelizeOptions {
+    dialect?: Dialect;
+    host?: string;
+    port?: number;
+    username?: string;
+    password?: string;
+    storage?: string;
+    logging?: boolean;
+    modelPaths?: string[];
+    models?: any[];
+    database?: string;
+    force?: boolean;
+    modifyFunctions?: {
+        sync?: () => {};
+    };
+}

package/dist/sequelize.interface.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SequelizeConfig = void 0;
+class SequelizeConfig {
+    constructor() {
+        this.modifyFunctions = {};
+    }
+}
+exports.SequelizeConfig = SequelizeConfig;

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@gapi/sequelize",
+  "version": "1.8.122",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Stradivario/gapi-sequelize.git"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "module": "./dist/index.js",
+  "typings": "./dist/index.d.ts",
+  "scripts": {
+    "patch": "npm run build && npm version patch && npm publish --update-readme --access public && npm run delete-dist",
+    "delete-dist": "rm -rf dist",
+    "clean": "git clean -dxf",
+    "lint": "npx eslint . --ext .ts",
+    "lint-fix": "npx eslint . --fix --ext .ts",
+    "build": "rm -rf dist && tsc || true"
+  },
+  "author": {
+    "name": "Kristian Tachev(Stradivario)",
+    "email": "kristiqn.tachev@gmail.com"
+  },
+  "keywords": [
+    "graphql",
+    "gapi",
+    "node"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "http://gitlab.youvolio.com/gapi/gapi-sequelize/issues"
+  },
+  "dependencies": {
+    "sequelize": "^5.8.2",
+    "sequelize-typescript": "^1.1.0"
+  },
+  "devDependencies": {
+    "@rxdi/core": "^0.7.114"
+  }
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+import { Module, ModuleWithServices } from '@rxdi/core';
+import { Sequelize } from 'sequelize-typescript';
+
+import { SEQUELIZE } from './sequelize-config.service';
+import { SequelizeConfig } from './sequelize.interface';
+
+@Module()
+export class SequelizeModule {
+  public static forRoot(config: SequelizeConfig): ModuleWithServices {
+    return {
+      module: SequelizeModule,
+      services: [
+        {
+          provide: SEQUELIZE,
+          lazy: true,
+          useFactory: async () => {
+            const sequelize = new Sequelize(config);
+            sequelize.addModels(config.models ? config.models : []);
+            await sequelize.sync(config);
+            return sequelize;
+          },
+        },
+      ],
+    };
+  }
+}
+
+export * from './sequelize.interface';
+export * from './sequelize-config.service';

package/src/sequelize-config.service.ts

@@ -0,0 +1,3 @@
+import { InjectionToken } from '@rxdi/core';
+
+export const SEQUELIZE = new InjectionToken('gapi-sequelize-config-token');

package/src/sequelize.interface.ts

@@ -0,0 +1,20 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { SequelizeOptions } from 'sequelize-typescript';
+import { Dialect } from 'sequelize/types';
+
+export class SequelizeConfig implements SequelizeOptions {
+  dialect?: Dialect;
+  host?: string;
+  port?: number;
+  username?: string;
+  password?: string;
+  storage?: string;
+  logging?: boolean;
+  modelPaths?: string[];
+  models?: any[];
+  database?: string;
+  force?: boolean;
+  modifyFunctions?: {
+    sync?: () => {};
+  } = {};
+}

package/tsconfig.json

@@ -0,0 +1,27 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "module": "commonjs",
+    "target": "es6",
+    "baseUrl": ".",
+    "stripInternal": true,
+    "emitDecoratorMetadata": true,
+    "experimentalDecorators": true,
+    "moduleResolution": "node",
+    "outDir": "dist",
+    "rootDir": "./src",
+    "lib": [
+      "es2017",
+      "es2016",
+      "es2015",
+      "es6",
+      "dom",
+      "esnext.asynciterable"
+    ],
+    "skipLibCheck": true,
+    "types": []
+  },
+  "files": [
+    "./src/index.ts"
+  ]
+}