@midwayjs/typeorm 3.4.0-beta.1

package/README.md

@@ -0,0 +1,96 @@
+# midway typeorm component
+
+## How to use
+
+in Configuration.ts file
+
+```ts
+import * as typeorm from '@midwayjs/typeorm';
+import { join } from 'path';
+
+@Configuration({
+  imports: [
+    typeorm,
+  ],
+  importConfigs: [
+    join(__dirname, './config')
+  ]
+})
+export class ContainerConfiguration {
+}
+
+```
+
+## Configuration
+
+in config files
+
+```ts
+export default {
+  typeorm: {
+    dataSource: {
+      default: {
+        type: 'mysql',
+        host: '',
+        port: 3306,
+        username: '',
+        password: '',
+        database: undefined,
+        synchronize: true,
+        logging: false,
+      }
+    }
+  }
+};
+```
+
+## Define EntityModel
+
+```ts
+// model/user.ts
+import { Entity, PrimaryGeneratedColumn, Column, OneToMany } from 'typeorm';
+
+@Entity('test_user')
+export class Photo {
+  @PrimaryGeneratedColumn({ name: "id" })
+  id: number;
+
+  @Column({ name: "name" })
+  name: string;
+
+  @OneToMany(type => Message, message => message.sender)
+  messages: Message[];
+}
+```
+
+
+## Use Model
+
+in code files
+
+```ts
+import { InjectEntityModel } from '@midwayjs/orm';
+import { User } from './model/user';
+import { Repository } from 'typeorm';
+
+@Provide()
+export class UserService {
+
+  @InjectEntityModel(User)
+  userModel: Repository<User>;
+
+  async testUser() {
+    const u = new User();
+    u.name = 'oneuser1';
+    const uu = await this.userModel.save(u);
+    console.log('user one id = ', uu.id);
+
+    const user = new User();
+    user.id = 1;
+    const users = await this.userModel.findAndCount({
+      where: user
+    });
+    return 'hello world' + JSON.stringify(users);
+  }
+}
+```

package/dist/configuration.d.ts

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

package/dist/configuration.js

@@ -0,0 +1,62 @@
+"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.OrmConfiguration = void 0;
+const core_1 = require("@midwayjs/core");
+const decorator_1 = require("@midwayjs/decorator");
+const decorator_2 = require("./decorator");
+const dataSourceManager_1 = require("./dataSourceManager");
+const typeorm_1 = require("typeorm");
+let OrmConfiguration = class OrmConfiguration {
+    async init() {
+        this.decoratorService.registerPropertyHandler(decorator_2.ORM_MODEL_KEY, (propertyName, meta) => {
+            return this.dataSourceManager
+                .getDataSource(meta.connectionName)
+                .getRepository(meta.modelKey);
+        });
+    }
+    async onReady(container) {
+        (0, typeorm_1.useContainer)(container);
+        this.dataSourceManager = await container.getAsync(dataSourceManager_1.TypeORMDataSourceManager);
+    }
+    async onStop(container) {
+        const dataSourceManager = await container.getAsync(dataSourceManager_1.TypeORMDataSourceManager);
+        await dataSourceManager.stop();
+    }
+};
+__decorate([
+    (0, decorator_1.App)(),
+    __metadata("design:type", Object)
+], OrmConfiguration.prototype, "app", void 0);
+__decorate([
+    (0, decorator_1.Inject)(),
+    __metadata("design:type", core_1.MidwayDecoratorService)
+], OrmConfiguration.prototype, "decoratorService", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], OrmConfiguration.prototype, "init", null);
+OrmConfiguration = __decorate([
+    (0, decorator_1.Configuration)({
+        importConfigs: [
+            {
+                default: {
+                    typeorm: {},
+                },
+            },
+        ],
+        namespace: 'typeorm',
+    })
+], OrmConfiguration);
+exports.OrmConfiguration = OrmConfiguration;
+//# sourceMappingURL=configuration.js.map

package/dist/dataSourceManager.d.ts

@@ -0,0 +1,12 @@
+import { DataSourceManager, IMidwayContainer } from '@midwayjs/core';
+import { DataSource } from 'typeorm';
+export declare class TypeORMDataSourceManager extends DataSourceManager<DataSource> {
+    typeormConfig: any;
+    applicationContext: IMidwayContainer;
+    init(): Promise<void>;
+    getName(): string;
+    protected createDataSource(config: any, dataSourceName: string): Promise<DataSource>;
+    protected checkConnected(dataSource: DataSource): Promise<boolean>;
+    protected destroyDataSource(dataSource: DataSource): Promise<void>;
+}
+//# sourceMappingURL=dataSourceManager.d.ts.map

package/dist/dataSourceManager.js

@@ -0,0 +1,56 @@
+"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.TypeORMDataSourceManager = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const core_1 = require("@midwayjs/core");
+const typeorm_1 = require("typeorm");
+let TypeORMDataSourceManager = class TypeORMDataSourceManager extends core_1.DataSourceManager {
+    async init() {
+        await this.initDataSource(this.typeormConfig);
+    }
+    getName() {
+        return 'typeorm';
+    }
+    async createDataSource(config, dataSourceName) {
+        const dataSource = new typeorm_1.DataSource(config);
+        await dataSource.initialize();
+        return dataSource;
+    }
+    async checkConnected(dataSource) {
+        return dataSource.isInitialized;
+    }
+    async destroyDataSource(dataSource) {
+        if (dataSource.isInitialized) {
+            await dataSource.destroy();
+        }
+    }
+};
+__decorate([
+    (0, decorator_1.Config)('typeorm'),
+    __metadata("design:type", Object)
+], TypeORMDataSourceManager.prototype, "typeormConfig", void 0);
+__decorate([
+    (0, decorator_1.ApplicationContext)(),
+    __metadata("design:type", Object)
+], TypeORMDataSourceManager.prototype, "applicationContext", void 0);
+__decorate([
+    (0, decorator_1.Init)(),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], TypeORMDataSourceManager.prototype, "init", null);
+TypeORMDataSourceManager = __decorate([
+    (0, decorator_1.Provide)(),
+    (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)
+], TypeORMDataSourceManager);
+exports.TypeORMDataSourceManager = TypeORMDataSourceManager;
+//# sourceMappingURL=dataSourceManager.js.map

package/dist/decorator.d.ts

@@ -0,0 +1,10 @@
+export declare const ENTITY_MODEL_KEY = "typeorm:entity_model_key";
+export declare const EVENT_SUBSCRIBER_KEY = "typeorm:event_subscriber_key";
+export declare const ORM_MODEL_KEY = "typeorm:orm_model_key";
+export declare function InjectEntityModel(modelKey: any, connectionName?: string): PropertyDecorator;
+/**
+ * EventSubscriber - typeorm
+ * implements EntitySubscriberInterface
+ */
+export declare function EventSubscriberModel(): ClassDecorator;
+//# sourceMappingURL=decorator.d.ts.map

package/dist/decorator.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EventSubscriberModel = exports.InjectEntityModel = exports.ORM_MODEL_KEY = exports.EVENT_SUBSCRIBER_KEY = exports.ENTITY_MODEL_KEY = void 0;
+const decorator_1 = require("@midwayjs/decorator");
+const typeorm_1 = require("typeorm");
+exports.ENTITY_MODEL_KEY = 'typeorm:entity_model_key';
+exports.EVENT_SUBSCRIBER_KEY = 'typeorm:event_subscriber_key';
+exports.ORM_MODEL_KEY = 'typeorm:orm_model_key';
+function InjectEntityModel(modelKey, connectionName = 'default') {
+    return (0, decorator_1.createCustomPropertyDecorator)(exports.ORM_MODEL_KEY, {
+        modelKey,
+        connectionName,
+    });
+}
+exports.InjectEntityModel = InjectEntityModel;
+/**
+ * EventSubscriber - typeorm
+ * implements EntitySubscriberInterface
+ */
+function EventSubscriberModel() {
+    return function (target) {
+        (0, decorator_1.Provide)()(target);
+        (0, decorator_1.Scope)(decorator_1.ScopeEnum.Singleton)(target);
+        (0, typeorm_1.EventSubscriber)()(target);
+    };
+}
+exports.EventSubscriberModel = EventSubscriberModel;
+//# sourceMappingURL=decorator.js.map

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { ENTITY_MODEL_KEY, EVENT_SUBSCRIBER_KEY, ORM_MODEL_KEY, } from './decorator';
+export { OrmConfiguration as Configuration } from './configuration';
+export * from './decorator';
+export * from './interface';
+export * from './dataSourceManager';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,27 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Configuration = exports.ORM_MODEL_KEY = exports.EVENT_SUBSCRIBER_KEY = exports.ENTITY_MODEL_KEY = void 0;
+var decorator_1 = require("./decorator");
+Object.defineProperty(exports, "ENTITY_MODEL_KEY", { enumerable: true, get: function () { return decorator_1.ENTITY_MODEL_KEY; } });
+Object.defineProperty(exports, "EVENT_SUBSCRIBER_KEY", { enumerable: true, get: function () { return decorator_1.EVENT_SUBSCRIBER_KEY; } });
+Object.defineProperty(exports, "ORM_MODEL_KEY", { enumerable: true, get: function () { return decorator_1.ORM_MODEL_KEY; } });
+var configuration_1 = require("./configuration");
+Object.defineProperty(exports, "Configuration", { enumerable: true, get: function () { return configuration_1.OrmConfiguration; } });
+__exportStar(require("./decorator"), exports);
+__exportStar(require("./interface"), exports);
+__exportStar(require("./dataSourceManager"), exports);
+//# sourceMappingURL=index.js.map

package/dist/interface.d.ts

@@ -0,0 +1,4 @@
+import { DataSourceOptions } from 'typeorm';
+import { DataSourceManagerConfigOption } from '@midwayjs/core';
+export declare type typeormConfigOptions = DataSourceManagerConfigOption<DataSourceOptions>;
+//# 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 { typeormConfigOptions } from './dist/index';
+
+export * from './dist/index';
+
+declare module '@midwayjs/core/dist/interface' {
+  interface MidwayConfig {
+    orm?: PowerPartial<typeormConfigOptions>;
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@midwayjs/typeorm",
+  "version": "3.4.0-beta.1",
+  "main": "dist/index",
+  "typings": "index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts",
+    "index.d.ts"
+  ],
+  "devDependencies": {
+    "@midwayjs/core": "^3.4.0-beta.1",
+    "@midwayjs/decorator": "^3.4.0-beta.1",
+    "@midwayjs/mock": "^3.4.0-beta.1",
+    "sqlite3": "5.0.8",
+    "typeorm": "0.3.6"
+  },
+  "author": {
+    "name": "czy88840616",
+    "email": "czy88840616@gmail.com"
+  },
+  "engines": {
+    "node": ">=12"
+  },
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "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": "http://github.com/midwayjs/midway.git"
+  },
+  "gitHead": "14d8440f20978426184c988808343cc24bcf6e20"
+}