oak-backend-base 1.0.0

package/lib/AppLoader.d.ts

@@ -0,0 +1,13 @@
+import { AppLoader as GeneralAppLoader, RowStore, Context, EntityDict } from "oak-domain/lib/types";
+import { MySQLConfiguration } from 'oak-db/lib/MySQL/types/Configuration';
+export declare class AppLoader<ED extends EntityDict, Cxt extends Context<ED>> extends GeneralAppLoader<ED, Cxt> {
+    private dbStore;
+    private aspectDict;
+    private contextBuilder;
+    constructor(path: string, contextBuilder: (scene?: string) => (store: RowStore<ED, Cxt>) => Cxt, dbConfig: MySQLConfiguration);
+    mount(initialize?: true): Promise<void>;
+    unmount(): Promise<void>;
+    execAspect(name: string, context: Cxt, params?: any): Promise<any>;
+    initialize(dropIfExists?: boolean): Promise<void>;
+    getStore(): RowStore<ED, Cxt>;
+}

package/lib/AppLoader.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppLoader = void 0;
+const actionDef_1 = require("oak-domain/lib/store/actionDef");
+const types_1 = require("oak-domain/lib/types");
+const DbStore_1 = require("./DbStore");
+const index_1 = __importDefault(require("oak-common-aspect/lib/index"));
+function initTriggers(dbStore, path) {
+    const { triggers } = require(`${path}/lib/triggers/index`);
+    const { checkers } = require(`${path}/lib/checkers/index`);
+    const { ActionDefDict } = require(`${path}/lib/oak-app-domain/ActionDefDict`);
+    const { triggers: adTriggers, checkers: adCheckers } = (0, actionDef_1.analyzeActionDefDict)(dbStore.getSchema(), ActionDefDict);
+    triggers.forEach((trigger) => dbStore.registerTrigger(trigger));
+    adTriggers.forEach((trigger) => dbStore.registerTrigger(trigger));
+    checkers.forEach((checker) => dbStore.registerChecker(checker));
+    adCheckers.forEach((checker) => dbStore.registerChecker(checker));
+}
+class AppLoader extends types_1.AppLoader {
+    dbStore;
+    aspectDict;
+    contextBuilder;
+    constructor(path, contextBuilder, dbConfig) {
+        super(path);
+        const { storageSchema } = require(`${path}/lib/oak-app-domain/Storage`);
+        this.aspectDict = Object.assign({}, index_1.default, require(`${path}/lib/aspects/index`).aspectDict);
+        this.dbStore = new DbStore_1.DbStore(storageSchema, contextBuilder, dbConfig);
+        this.contextBuilder = contextBuilder;
+    }
+    async mount(initialize) {
+        const { path } = this;
+        if (!initialize) {
+            initTriggers(this.dbStore, path);
+        }
+        this.dbStore.connect();
+    }
+    async unmount() {
+        this.dbStore.disconnect();
+    }
+    async execAspect(name, context, params) {
+        const fn = this.aspectDict[name];
+        if (!fn) {
+            throw new Error(`不存在的接口名称: ${name}`);
+        }
+        return await fn(params, context);
+    }
+    async initialize(dropIfExists) {
+        await this.dbStore.initialize(dropIfExists);
+        const { data } = require(`${this.path}/lib/data/index`);
+        const context = this.contextBuilder()(this.dbStore);
+        await context.begin();
+        for (const entity in data) {
+            let rows = data[entity];
+            if (entity === 'area') {
+                //  对area暂时处理一下
+                rows = require('./data/area.json');
+            }
+            await this.dbStore.operate(entity, {
+                data: rows,
+                action: 'create',
+            }, context);
+            console.log(`data in ${entity} initialized!`);
+        }
+        await context.commit();
+        this.dbStore.disconnect();
+    }
+    getStore() {
+        return this.dbStore;
+    }
+}
+exports.AppLoader = AppLoader;

package/lib/BackendContext.d.ts

@@ -0,0 +1,6 @@
+import { RowStore } from 'oak-domain/lib/types';
+import { GeneralRuntimeContext } from 'oak-general-business';
+import { EntityDict } from 'oak-general-business/lib/general-app-domain';
+export declare class Context<ED extends EntityDict> extends GeneralRuntimeContext<ED> {
+    static FromCxtStr(cxtStr?: string): <ED extends EntityDict>(store: RowStore<ED, Context<ED>>) => Context<ED>;
+}

package/lib/BackendContext.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const oak_general_business_1 = require("oak-general-business");
+class Context extends oak_general_business_1.GeneralRuntimeContext {
+    static FromCxtStr(cxtStr) {
+        const { token, applicationId, scene } = cxtStr ? oak_general_business_1.GeneralRuntimeContext.fromString(cxtStr) : {
+            token: undefined,
+            applicationId: undefined,
+            scene: undefined,
+        };
+        return (store) => {
+            const context = new Context(store, applicationId);
+            context.setScene(scene);
+            context.setToken(token);
+            return context;
+        };
+    }
+}
+exports.Context = Context;

package/lib/DbStore.d.ts

@@ -0,0 +1,13 @@
+import { MysqlStore, MySqlSelectOption, MysqlOperateOption } from 'oak-db';
+import { EntityDict, Context, StorageSchema, SelectionResult, Trigger, Checker, SelectRowShape, RowStore } from 'oak-domain/lib/types';
+import { MySQLConfiguration } from 'oak-db/lib/MySQL/types/Configuration';
+export declare class DbStore<ED extends EntityDict, Cxt extends Context<ED>> extends MysqlStore<ED, Cxt> {
+    private executor;
+    constructor(storageSchema: StorageSchema<ED>, contextBuilder: (scene?: string) => (store: RowStore<ED, Cxt>) => Cxt, mysqlConfiguration: MySQLConfiguration);
+    protected cascadeUpdate<T extends keyof ED>(entity: T, operation: ED[T]['Create'] | ED[T]['Update'] | ED[T]['Remove'], context: Cxt, option?: MysqlOperateOption): Promise<import("oak-domain/lib/types").OperationResult<ED>>;
+    protected cascadeSelect<T extends keyof ED, S extends ED[T]["Selection"]>(entity: T, selection: S, context: Cxt, option?: MySqlSelectOption): Promise<SelectRowShape<ED[T]['Schema'], S['data']>[]>;
+    operate<T extends keyof ED>(entity: T, operation: ED[T]['Operation'], context: Cxt, params?: MysqlOperateOption): Promise<import("oak-domain/lib/types").OperationResult<ED>>;
+    select<T extends keyof ED, S extends ED[T]['Selection']>(entity: T, selection: S, context: Cxt, params?: MySqlSelectOption): Promise<SelectionResult<ED[T]["Schema"], S["data"]>>;
+    registerTrigger<T extends keyof ED>(trigger: Trigger<ED, T, Cxt>): void;
+    registerChecker<T extends keyof ED>(checker: Checker<ED, T, Cxt>): void;
+}

package/lib/DbStore.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DbStore = void 0;
+const oak_db_1 = require("oak-db");
+const TriggerExecutor_1 = require("oak-domain/lib/store/TriggerExecutor");
+class DbStore extends oak_db_1.MysqlStore {
+    executor;
+    constructor(storageSchema, contextBuilder, mysqlConfiguration) {
+        super(storageSchema, mysqlConfiguration);
+        this.executor = new TriggerExecutor_1.TriggerExecutor(async (scene) => contextBuilder(scene)(this));
+    }
+    async cascadeUpdate(entity, operation, context, option) {
+        await this.executor.preOperation(entity, operation, context, option);
+        const result = super.cascadeUpdate(entity, operation, context, option);
+        await this.executor.postOperation(entity, operation, context, option);
+        return result;
+    }
+    async cascadeSelect(entity, selection, context, option) {
+        const selection2 = Object.assign({
+            action: 'select',
+        }, selection);
+        if (!option?.ignoreTrigger) {
+            await this.executor.preOperation(entity, selection2, context, option);
+        }
+        const result = await super.cascadeSelect(entity, selection2, context, option);
+        if (!option?.ignoreTrigger) {
+            await this.executor.postOperation(entity, selection2, context, option, result);
+        }
+        return result;
+    }
+    async operate(entity, operation, context, params) {
+        const autoCommit = !context.getCurrentTxnId();
+        let result;
+        if (autoCommit) {
+            await context.begin();
+        }
+        try {
+            result = await super.operate(entity, operation, context, params);
+        }
+        catch (err) {
+            await context.rollback();
+            throw err;
+        }
+        if (autoCommit) {
+            await context.commit();
+        }
+        return result;
+    }
+    async select(entity, selection, context, params) {
+        const autoCommit = !context.getCurrentTxnId();
+        if (autoCommit) {
+            await context.begin();
+        }
+        let result;
+        try {
+            result = await super.select(entity, selection, context, params);
+        }
+        catch (err) {
+            await context.rollback();
+            throw err;
+        }
+        if (autoCommit) {
+            await context.commit();
+        }
+        return result;
+    }
+    registerTrigger(trigger) {
+        this.executor.registerTrigger(trigger);
+    }
+    registerChecker(checker) {
+        this.executor.registerChecker(checker);
+    }
+}
+exports.DbStore = DbStore;

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { Context as BackendContext } from './BackendContext';
+export { AppLoader } from './AppLoader';

package/lib/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppLoader = exports.BackendContext = void 0;
+var BackendContext_1 = require("./BackendContext");
+Object.defineProperty(exports, "BackendContext", { enumerable: true, get: function () { return BackendContext_1.Context; } });
+var AppLoader_1 = require("./AppLoader");
+Object.defineProperty(exports, "AppLoader", { enumerable: true, get: function () { return AppLoader_1.AppLoader; } });

package/lib/polyfill.d.ts

@@ -0,0 +1,3 @@
+export declare type GenerateIdOption = {
+    shuffle?: boolean;
+};

package/lib/polyfill.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const uuid_1 = require("uuid");
+async function generateNewId(option) {
+    if (option?.shuffle && process.env.NODE_ENV === 'development') {
+        return (0, uuid_1.v4)();
+    }
+    return (0, uuid_1.v1)();
+}
+Object.assign(global, {
+    generateNewId,
+});

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "oak-backend-base",
+  "version": "1.0.0",
+  "description": "oak-backend-base",
+  "main": "src/index",
+  "author": {
+      "name": "XuChang"
+  },
+  "scripts": {
+    "test": "ts-node test/test.ts",
+    "build": "tsc"
+  },
+  "dependencies": {
+    "koa": "^2.13.4",
+    "koa-body": "^5.0.0",
+    "koa-router": "^10.1.1",
+    "lodash": "^4.17.21",
+    "mysql": "^2.18.1",
+    "mysql2": "^2.3.3",
+    "oak-db": "^1.0.0",
+    "oak-domain": "^1.0.0",
+    "oak-general-business": "^1.0.0",
+    "oak-common-aspect": "^1.0.0",
+    "uuid": "^8.3.2"
+  },
+  "license": "ISC",
+  "devDependencies": {
+    "@types/koa": "^2.13.4",
+    "@types/koa-router": "^7.4.4",
+    "@types/node": "^17.0.40",
+    "@types/uuid": "^8.3.4",
+    "ts-node": "^10.8.1",
+    "typescript": "^4.7.3"
+  }
+}

package/src/AppLoader.ts

@@ -0,0 +1,85 @@
+import { analyzeActionDefDict } from "oak-domain/lib/store/actionDef";
+import { AppLoader as GeneralAppLoader, Trigger, Checker, Aspect, RowStore, Context, EntityDict } from "oak-domain/lib/types";
+import { DbStore } from "./DbStore";
+import generalAspectDict from 'oak-common-aspect/lib/index';
+import { MySQLConfiguration } from 'oak-db/lib/MySQL/types/Configuration';
+
+function initTriggers<ED extends EntityDict, Cxt extends Context<ED>>(dbStore: DbStore<ED, Cxt>, path: string) {
+    const { triggers } = require(`${path}/lib/triggers/index`);
+    const { checkers } = require(`${path}/lib/checkers/index`);
+    const { ActionDefDict } = require(`${path}/lib/oak-app-domain/ActionDefDict`);
+
+    const { triggers: adTriggers, checkers: adCheckers } = analyzeActionDefDict(dbStore.getSchema(), ActionDefDict);
+    triggers.forEach(
+        (trigger: Trigger<ED, keyof ED, Cxt>) => dbStore.registerTrigger(trigger)
+    );
+    adTriggers.forEach(
+        (trigger) => dbStore.registerTrigger(trigger)
+    );
+    checkers.forEach(
+        (checker: Checker<ED, keyof ED, Cxt>) => dbStore.registerChecker(checker)
+    );
+    adCheckers.forEach(
+        (checker) => dbStore.registerChecker(checker)
+    );
+}
+
+
+export class AppLoader<ED extends EntityDict, Cxt extends Context<ED>> extends GeneralAppLoader<ED, Cxt> {
+    private dbStore: DbStore<ED, Cxt>;
+    private aspectDict: Record<string, Aspect<ED, Cxt>>;
+    private contextBuilder: (scene?: string) => (store: RowStore<ED, Cxt>) => Cxt;
+    constructor(path: string, contextBuilder: (scene?: string) => (store: RowStore<ED, Cxt>) => Cxt, dbConfig: MySQLConfiguration) {
+        super(path);
+        const { storageSchema } = require(`${path}/lib/oak-app-domain/Storage`);
+        this.aspectDict = Object.assign({}, generalAspectDict, require(`${path}/lib/aspects/index`).aspectDict);
+        this.dbStore = new DbStore<ED, Cxt>(storageSchema, contextBuilder, dbConfig);
+        this.contextBuilder = contextBuilder;
+    }
+
+    async mount(initialize?: true) {
+        const { path } = this;
+        if (!initialize) {
+            initTriggers(this.dbStore, path);
+        }
+        this.dbStore.connect();
+    }
+
+    async unmount() {
+        this.dbStore.disconnect();
+    }
+
+    async execAspect(name: string, context: Cxt, params?: any): Promise<any> {
+        const fn = this.aspectDict[name];
+        if (!fn) {
+            throw new Error(`不存在的接口名称: ${name}`);
+        }
+        return await fn(params, context);
+    }
+
+    async initialize(dropIfExists?: boolean) {
+        await this.dbStore.initialize(dropIfExists);
+
+        const { data } = require(`${this.path}/lib/data/index`);
+        const context = this.contextBuilder()(this.dbStore);
+        await context.begin();
+        for (const entity in data) {
+            let rows = data[entity];
+            if (entity === 'area') {
+                //  对area暂时处理一下
+                rows = require('./data/area.json');
+            }
+            await this.dbStore.operate(entity as keyof ED, {
+                data: rows,
+                action: 'create',
+            } as any, context);
+            console.log(`data in ${entity} initialized!`);
+        }
+        await context.commit();
+        this.dbStore.disconnect();
+    }
+
+    getStore(): RowStore<ED, Cxt> {
+        return this.dbStore;
+    }
+}

package/src/BackendContext.ts

@@ -0,0 +1,23 @@
+import { RowStore } from 'oak-domain/lib/types';
+import { GeneralRuntimeContext } from 'oak-general-business';
+import { EntityDict } from 'oak-general-business/lib/general-app-domain';
+
+export class Context<ED extends EntityDict> extends GeneralRuntimeContext<ED> {
+    static FromCxtStr(cxtStr?: string){
+        const {
+            token,
+            applicationId,
+            scene
+        } = cxtStr ? GeneralRuntimeContext.fromString(cxtStr) : {
+            token: undefined,
+            applicationId: undefined,
+            scene: undefined,
+        };
+        return <ED extends EntityDict>(store: RowStore<ED, Context<ED>>) => {
+            const context = new Context<ED>(store, applicationId);
+            context.setScene(scene);
+            context.setToken(token);
+            return context;
+        };
+    }
+}

package/src/DbStore.ts

@@ -0,0 +1,94 @@
+import { MysqlStore, MySqlSelectOption, MysqlOperateOption } from 'oak-db';
+import { EntityDict, Context, StorageSchema, OperateOption, SelectionResult, Trigger, Checker, SelectRowShape, RowStore } from 'oak-domain/lib/types';
+import { TriggerExecutor } from 'oak-domain/lib/store/TriggerExecutor';
+import { MySQLConfiguration, } from 'oak-db/lib/MySQL/types/Configuration';
+
+
+export class DbStore<ED extends EntityDict, Cxt extends Context<ED>> extends MysqlStore<ED, Cxt> {
+    private executor: TriggerExecutor<ED, Cxt>;
+
+    constructor(storageSchema: StorageSchema<ED>, contextBuilder: (scene?: string) => (store: RowStore<ED, Cxt>) => Cxt, mysqlConfiguration: MySQLConfiguration) {
+        super(storageSchema, mysqlConfiguration);
+        this.executor = new TriggerExecutor(async (scene) => contextBuilder(scene)(this));
+    }
+
+
+    protected async cascadeUpdate<T extends keyof ED>(entity: T, operation: ED[T]['Create'] | ED[T]['Update'] | ED[T]['Remove'], context: Cxt, option?: MysqlOperateOption) {
+        await this.executor.preOperation(entity, operation, context, option);
+        const result = super.cascadeUpdate(entity, operation, context, option);
+        await this.executor.postOperation(entity, operation, context, option);
+        return result;
+    }
+
+    protected async cascadeSelect<T extends keyof ED, S extends ED[T]["Selection"]>(entity: T, selection: S, context: Cxt, option?: MySqlSelectOption): Promise<SelectRowShape<ED[T]['Schema'], S['data']>[]> {
+        const selection2 = Object.assign({
+            action: 'select',
+        }, selection) as ED[T]['Operation'];
+
+        if (!option?.ignoreTrigger) {
+            await this.executor.preOperation(entity, selection2, context, option);
+        }
+        const result = await super.cascadeSelect(entity, selection2 as any, context, option);
+        if (!option?.ignoreTrigger) {
+            await this.executor.postOperation(entity, selection2, context, option, result);
+        }
+        return result;
+    }
+
+    async operate<T extends keyof ED>(
+        entity: T,
+        operation: ED[T]['Operation'],
+        context: Cxt,
+        params?: MysqlOperateOption
+    ) {
+        const autoCommit = !context.getCurrentTxnId();
+        let result;
+        if (autoCommit) {
+            await context.begin();
+        }
+        try {
+            result = await super.operate(entity, operation, context, params);
+        }
+        catch (err) {
+            await context.rollback();
+            throw err;
+        }
+        if (autoCommit) {
+            await context.commit();
+        }
+        return result;
+    }
+
+    async select<T extends keyof ED, S extends ED[T]['Selection']>(
+        entity: T,
+        selection: S,
+        context: Cxt,
+        params?: MySqlSelectOption
+    ) {
+        const autoCommit = !context.getCurrentTxnId();
+        if (autoCommit) {
+            await context.begin();
+        }
+        let result: SelectionResult<ED[T]['Schema'], S['data']>;
+
+        try {
+            result = await super.select(entity, selection, context, params);
+        }
+        catch (err) {
+            await context.rollback();
+            throw err;
+        }
+        if (autoCommit) {
+            await context.commit();
+        }
+        return result;
+    }
+
+    registerTrigger<T extends keyof ED>(trigger: Trigger<ED, T, Cxt>) {
+        this.executor.registerTrigger(trigger);
+    }
+
+    registerChecker<T extends keyof ED>(checker: Checker<ED, T, Cxt>) {
+        this.executor.registerChecker(checker);
+    }
+}