@midwayjs/leoric 3.0.0

package/README.md

@@ -0,0 +1,63 @@
+# midway leoric component
+
+this is a sub package for midway.
+
+Document: [https://midwayjs.org](https://midwayjs.org)
+
+## Usage
+
+```ts
+// src/configuration.ts
+import { Configuration, ILifeCycle } from '@midwayjs/core';
+import * as leoric from '@midwayjs/leoric';
+
+@Configuration({
+  imports: [
+    leoric,
+  ],
+
+})
+export class ContainerLifeCycle implements ILifeCycle {}
+```
+
+```ts
+// src/config/config.default.ts
+export default () => {
+  return {
+    leoric: {
+      dataSource: {
+        default: {
+          dialect: 'sqlite',
+          database: path.join(__dirname, '../../', 'database.sqlite'),
+          sync: true,
+          models: [
+            '**/models/*{.ts,.js}'
+          ]
+        },
+      },
+    },
+  }
+}
+```
+
+```ts
+// src/controller/user.ts
+import { Controller } from '@midwayjs/core';
+import { InjectModel } from '@midwayjs/leoric';
+import User from '../model/user';
+
+@Controller('/api/users')
+export class UserController {
+  @InjectModel(User)
+  User: typeof User;
+
+  @Get('/')
+  async index() {
+    return await this.User.order('id', 'desc').limit(10);
+  }
+}
+```
+
+## License
+
+[MIT]((http://github.com/midwayjs/midway/blob/master/LICENSE))

package/dist/configuration.d.ts

@@ -0,0 +1,10 @@
+import { IMidwayContainer, MidwayDecoratorService } from '@midwayjs/core';
+import { LeoricDataSourceManager } from './dataSourceManager';
+export declare class LeoricConfiguration {
+    decoratorService: MidwayDecoratorService;
+    dataSourceManager: LeoricDataSourceManager;
+    init(): Promise<void>;
+    onReady(container: IMidwayContainer): Promise<void>;
+    onStop(): Promise<void>;
+}
+//# sourceMappingURL=configuration.d.ts.map

package/dist/configuration.js

@@ -0,0 +1,65 @@
+"use strict";
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeoricConfiguration = void 0;
+const core_1 = require("@midwayjs/core");
+const dataSourceManager_1 = require("./dataSourceManager");
+const decorator_1 = require("./decorator");
+function getModelName(model) {
+    if (typeof model === 'string')
+        return model;
+    return model.name;
+}
+let LeoricConfiguration = class LeoricConfiguration {
+    async init() {
+        this.decoratorService.registerPropertyHandler(decorator_1.MODEL_KEY, (propertyName, meta) => {
+            return this.dataSourceManager.getDataSource(meta.connectionName ||
+                this.dataSourceManager.getDataSourceNameByModel(meta.modelName) ||
+                this.dataSourceManager.getDefaultDataSourceName()).models[getModelName(meta.modelName)];
+        });
+        this.decoratorService.registerPropertyHandler(decorator_1.DATA_SOURCE_KEY, (propertyName, meta) => {
+            return this.dataSourceManager.getDataSource(meta.dataSourceName ||
+                this.dataSourceManager.getDefaultDataSourceName());
+        });
+    }
+    async onReady(container) {
+        this.dataSourceManager = await container.getAsync(dataSourceManager_1.LeoricDataSourceManager);
+    }
+    async onStop() {
+        if (this.dataSourceManager) {
+            await this.dataSourceManager.stop();
+        }
+    }
+};
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", core_1.MidwayDecoratorService)
+], LeoricConfiguration.prototype, "decoratorService", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], LeoricConfiguration.prototype, "init", null);
+LeoricConfiguration = __decorate([
+    (0, core_1.Configuration)({
+        namespace: 'leoric',
+        importConfigs: [
+            {
+                default: {
+                    leoric: {},
+                },
+            },
+        ],
+    })
+], LeoricConfiguration);
+exports.LeoricConfiguration = LeoricConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/dataSourceManager.d.ts

@@ -0,0 +1,14 @@
+import { DataSourceManager, ILogger } from '@midwayjs/core';
+import Realm, { ConnectOptions } from 'leoric';
+import { LeoricConfigOption } from './interface';
+export declare class LeoricDataSourceManager extends DataSourceManager<Realm, ConnectOptions> {
+    leoricConfig: LeoricConfigOption;
+    coreLogger: ILogger;
+    baseDir: string;
+    init(): Promise<void>;
+    getName(): string;
+    protected createDataSource(config: any, dataSourceName: string): Promise<Realm>;
+    protected checkConnected(dataSource: Realm): Promise<boolean>;
+    protected destroyDataSource(dataSource: Realm): Promise<void>;
+}
+//# sourceMappingURL=dataSourceManager.d.ts.map

package/dist/dataSourceManager.js

@@ -0,0 +1,99 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LeoricDataSourceManager = void 0;
+const core_1 = require("@midwayjs/core");
+const leoric_1 = __importStar(require("leoric"));
+let LeoricDataSourceManager = class LeoricDataSourceManager extends core_1.DataSourceManager {
+    async init() {
+        await this.initDataSource(this.leoricConfig, {
+            baseDir: this.baseDir,
+            entitiesConfigKey: 'models',
+        });
+    }
+    getName() {
+        return 'leoric';
+    }
+    async createDataSource(config, dataSourceName) {
+        const { sync, models, ...options } = config;
+        const realm = new leoric_1.default({
+            ...options,
+            models: models.filter(el => (0, leoric_1.isBone)(el)),
+        });
+        await realm.connect();
+        this.coreLogger.info('[midway:leoric] connecting and start');
+        if (sync)
+            await realm.sync();
+        return realm;
+    }
+    async checkConnected(dataSource) {
+        try {
+            await dataSource.connect();
+            return true;
+        }
+        catch (err) {
+            this.coreLogger.error(err);
+            return false;
+        }
+    }
+    async destroyDataSource(dataSource) {
+        if (await this.checkConnected(dataSource)) {
+            await dataSource.disconnect();
+        }
+    }
+};
+__decorate([
+    (0, core_1.Config)('leoric'),
+    __metadata("design:type", Object)
+], LeoricDataSourceManager.prototype, "leoricConfig", void 0);
+__decorate([
+    (0, core_1.Logger)('coreLogger'),
+    __metadata("design:type", Object)
+], LeoricDataSourceManager.prototype, "coreLogger", void 0);
+__decorate([
+    (0, core_1.Inject)(),
+    __metadata("design:type", String)
+], LeoricDataSourceManager.prototype, "baseDir", void 0);
+__decorate([
+    (0, core_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], LeoricDataSourceManager.prototype, "init", null);
+LeoricDataSourceManager = __decorate([
+    (0, core_1.Provide)(),
+    (0, core_1.Scope)(core_1.ScopeEnum.Singleton)
+], LeoricDataSourceManager);
+exports.LeoricDataSourceManager = LeoricDataSourceManager;
+//# sourceMappingURL=dataSourceManager.js.map

package/dist/decorator.d.ts

@@ -0,0 +1,6 @@
+import { ClassLikeBone } from './interface';
+export declare const MODEL_KEY = "leoric:model_key";
+export declare const DATA_SOURCE_KEY = "leoric:data_source_key";
+export declare function InjectDataSource(dataSourceName?: string): PropertyDecorator;
+export declare function InjectModel(modelName?: string | ClassLikeBone, dataSourceName?: string): (target: object, propertyKey: string | symbol) => void;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/decorator.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectModel = exports.InjectDataSource = exports.DATA_SOURCE_KEY = exports.MODEL_KEY = void 0;
+const core_1 = require("@midwayjs/core");
+exports.MODEL_KEY = 'leoric:model_key';
+exports.DATA_SOURCE_KEY = 'leoric:data_source_key';
+function InjectDataSource(dataSourceName) {
+    return (0, core_1.createCustomPropertyDecorator)(exports.DATA_SOURCE_KEY, { dataSourceName });
+}
+exports.InjectDataSource = InjectDataSource;
+function InjectModel(modelName, dataSourceName) {
+    return (target, propertyKey) => {
+        if (!modelName)
+            modelName = propertyKey.toString();
+        return (0, core_1.createCustomPropertyDecorator)(exports.MODEL_KEY, {
+            modelName,
+            dataSourceName,
+        })(target, propertyKey);
+    };
+}
+exports.InjectModel = InjectModel;
+//# sourceMappingURL=decorator.js.map

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import Realm from 'leoric';
+export * from 'leoric';
+export { Realm };
+export { LeoricConfiguration as Configuration } from './configuration';
+export { InjectDataSource, InjectModel } from './decorator';
+export * from './dataSourceManager';
+export * from './interface';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InjectModel = exports.InjectDataSource = exports.Configuration = exports.Realm = void 0;
+const leoric_1 = __importDefault(require("leoric"));
+exports.Realm = leoric_1.default;
+__exportStar(require("leoric"), exports);
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.LeoricConfiguration; } });
+var decorator_1 = require("./decorator");
+Object.defineProperty(exports, "InjectDataSource", { enumerable: true, get: function () { return decorator_1.InjectDataSource; } });
+Object.defineProperty(exports, "InjectModel", { enumerable: true, get: function () { return decorator_1.InjectModel; } });
+__exportStar(require("./dataSourceManager"), exports);
+__exportStar(require("./interface"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,5 @@
+import { DataSourceManagerConfigOption } from '@midwayjs/core';
+import { Bone, ConnectOptions } from 'leoric';
+export type LeoricConfigOption = DataSourceManagerConfigOption<ConnectOptions, 'models'>;
+export type ClassLikeBone = new (...args: any[]) => Bone;
+//# sourceMappingURL=interface.d.ts.map

package/dist/interface.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=interface.js.map

package/index.d.ts

@@ -0,0 +1,9 @@
+import { LeoricConfigOption } from './dist/index';
+
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    leoric?: LeoricConfigOption;
+  }
+}

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@midwayjs/leoric",
+  "version": "3.0.0",
+  "description": "Leoric as a Midway model component",
+  "main": "dist/index.js",
+  "typings": "index.d.ts",
+  "keywords": [
+    "midway",
+    "component",
+    "leoric",
+    "orm"
+  ],
+  "author": "Chen Yangjian (https://www.cyj.me)",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "leoric": "2.11.1"
+  },
+  "devDependencies": {
+    "@midwayjs/core": "^3.11.1",
+    "@midwayjs/mock": "^3.11.3",
+    "sqlite3": "5.1.6"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepack": "npm run build",
+    "test": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand",
+    "cov": "node --require=ts-node/register ../../node_modules/.bin/jest --runInBand --coverage --forceExit"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/midwayjs/midway.git"
+  }
+}