oak-domain 4.2.2 → 4.2.4

package/lib/utils/projection.d.ts

@@ -1,4 +1,4 @@
-import { EntityDict } from '../types/Entity';
-import { EntityDict as BaseEntityDict } from '../base-app-domain';
-import { StorageSchema } from '../types/Storage';
-export declare function makeProjection<ED extends BaseEntityDict & EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>): ED[T]["Selection"]["data"];
+import { EntityDict } from '../types/Entity';
+import { EntityDict as BaseEntityDict } from '../base-app-domain';
+import { StorageSchema } from '../types/Storage';
+export declare function makeProjection<ED extends BaseEntityDict & EntityDict, T extends keyof ED>(entity: T, schema: StorageSchema<ED>): ED[T]["Selection"]["data"];

package/lib/utils/relationPath.d.ts

@@ -1,31 +1,31 @@
-import { StorageSchema } from '../types/Storage';
-import { EntityDict as BaseEntityDict } from "../base-app-domain";
-import { EntityDict } from "../types/Entity";
-/**
- * 根据entity的相对path，以及定义的userRelationFilter，找到根结点对象上相应的userRelations
- * @param schema
- * @param entity
- * @param path
- * @param relationFilter
- * @param recursive
- */
-export declare function destructRelationPath<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(schema: StorageSchema<ED>, entity: T, path: string, relationFilter: ED['userRelation']['Selection']['filter'], recursive?: boolean): {
-    projection: ED[T]['Selection']['data'];
-    getData: (d: Partial<ED[T]['Schema']>) => ED['userRelation']['Schema'][] | undefined;
-};
-/**
- * 根据entity的相对path，找到对应的根结点对象上的直接userId
- * @param schema
- * @param entity
- * @param path
- * @param recursive
- * @returns
- */
-export declare function destructDirectPath<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(schema: StorageSchema<ED>, entity: T, path: string, recursive?: boolean): {
-    projection: ED[T]['Selection']['data'];
-    getData: (d: Partial<ED[T]['Schema']>) => {
-        entity: keyof ED;
-        entityId: string;
-        userId: string;
-    }[] | undefined;
-};
+import { StorageSchema } from '../types/Storage';
+import { EntityDict as BaseEntityDict } from "../base-app-domain";
+import { EntityDict } from "../types/Entity";
+/**
+ * 根据entity的相对path，以及定义的userRelationFilter，找到根结点对象上相应的userRelations
+ * @param schema
+ * @param entity
+ * @param path
+ * @param relationFilter
+ * @param recursive
+ */
+export declare function destructRelationPath<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(schema: StorageSchema<ED>, entity: T, path: string, relationFilter: ED['userRelation']['Selection']['filter'], recursive?: boolean): {
+    projection: ED[T]['Selection']['data'];
+    getData: (d: Partial<ED[T]['Schema']>) => ED['userRelation']['Schema'][] | undefined;
+};
+/**
+ * 根据entity的相对path，找到对应的根结点对象上的直接userId
+ * @param schema
+ * @param entity
+ * @param path
+ * @param recursive
+ * @returns
+ */
+export declare function destructDirectPath<ED extends EntityDict & BaseEntityDict, T extends keyof ED>(schema: StorageSchema<ED>, entity: T, path: string, recursive?: boolean): {
+    projection: ED[T]['Selection']['data'];
+    getData: (d: Partial<ED[T]['Schema']>) => {
+        entity: keyof ED;
+        entityId: string;
+        userId: string;
+    }[] | undefined;
+};

package/lib/utils/relationPath.js

@@ -1,202 +1,202 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.destructDirectPath = exports.destructRelationPath = void 0;
-const tslib_1 = require("tslib");
-const assert_1 = tslib_1.__importDefault(require("assert"));
-const relation_1 = require("../store/relation");
-/**
- * 根据entity的相对path，以及定义的userRelationFilter，找到根结点对象上相应的userRelations
- * @param schema
- * @param entity
- * @param path
- * @param relationFilter
- * @param recursive
- */
-function destructRelationPath(schema, entity, path, relationFilter, recursive) {
-    (0, assert_1.default)(!recursive, 'recursive的情况还没处理，等跑出来再说， by Xc');
-    if (path === '') {
-        return {
-            projection: {
-                id: 1,
-                userRelation$entity: {
-                    $entity: 'userRelation',
-                    data: {
-                        id: 1,
-                        relationId: 1,
-                        relation: {
-                            id: 1,
-                            name: 1,
-                        },
-                        entity: 1,
-                        entityId: 1,
-                        userId: 1,
-                    },
-                    filter: relationFilter,
-                },
-            },
-            getData: (d) => {
-                return d.userRelation$entity;
-            },
-        };
-    }
-    const paths = path.split('.');
-    const makeIter = (e, idx) => {
-        if (idx === paths.length) {
-            return {
-                projection: {
-                    id: 1,
-                    userRelation$entity: {
-                        $entity: 'userRelation',
-                        data: {
-                            id: 1,
-                            relationId: 1,
-                            relation: {
-                                id: 1,
-                                name: 1,
-                            },
-                            entity: 1,
-                            entityId: 1,
-                            userId: 1,
-                        },
-                        filter: relationFilter,
-                    } // as ED['userRelation']['Selection']
-                },
-                getData: (d) => {
-                    return d.userRelation$entity;
-                },
-            };
-        }
-        const attr = paths[idx];
-        const rel = (0, relation_1.judgeRelation)(schema, e, attr);
-        if (rel === 2) {
-            const { projection, getData } = makeIter(attr, idx + 1);
-            return {
-                projection: {
-                    id: 1,
-                    [attr]: projection,
-                },
-                getData: (d) => d[attr] && getData(d[attr]),
-            };
-        }
-        else if (typeof rel === 'string') {
-            const { projection, getData } = makeIter(rel, idx + 1);
-            return {
-                projection: {
-                    id: 1,
-                    [attr]: projection,
-                },
-                getData: (d) => d[attr] && getData(d[attr]),
-            };
-        }
-        else {
-            (0, assert_1.default)(rel instanceof Array);
-            const [e2] = rel;
-            const { projection, getData } = makeIter(e2, idx + 1);
-            return {
-                projection: {
-                    id: 1,
-                    [attr]: {
-                        $entity: e2,
-                        data: projection,
-                    },
-                },
-                getData: (d) => d[attr] && d[attr].map(ele => getData(ele)).flat().filter(ele => !!ele),
-            };
-        }
-    };
-    return makeIter(entity, 0);
-}
-exports.destructRelationPath = destructRelationPath;
-/**
- * 根据entity的相对path，找到对应的根结点对象上的直接userId
- * @param schema
- * @param entity
- * @param path
- * @param recursive
- * @returns
- */
-function destructDirectPath(schema, entity, path, recursive) {
-    (0, assert_1.default)(!recursive, '直接对象上不可能有recursive');
-    (0, assert_1.default)(path, '直接对象的路径最终要指向user对象，不可能为空');
-    const paths = path.split('.');
-    const makeIter = (e, idx) => {
-        const attr = paths[idx];
-        const rel = (0, relation_1.judgeRelation)(schema, e, attr);
-        if (idx === paths.length - 1) {
-            if (rel === 2) {
-                (0, assert_1.default)(attr === 'user');
-                return {
-                    projection: {
-                        id: 1,
-                        entity: 1,
-                        entityId: 1,
-                    },
-                    getData: (d) => {
-                        if (d) {
-                            return [{
-                                    entity: e,
-                                    entityId: d.id,
-                                    userId: d.entityId,
-                                }];
-                        }
-                    },
-                };
-            }
-            else {
-                (0, assert_1.default)(rel === 'user');
-                return {
-                    projection: {
-                        id: 1,
-                        [`${attr}Id`]: 1,
-                    },
-                    getData: (d) => {
-                        if (d) {
-                            return [{
-                                    entity: e,
-                                    entityId: d.id,
-                                    userId: d[`${attr}Id`],
-                                }];
-                        }
-                    },
-                };
-            }
-        }
-        if (rel === 2) {
-            const { projection, getData } = makeIter(attr, idx + 1);
-            return {
-                projection: {
-                    id: 1,
-                    [attr]: projection,
-                },
-                getData: (d) => d[attr] && getData(d[attr]),
-            };
-        }
-        else if (typeof rel === 'string') {
-            const { projection, getData } = makeIter(rel, idx + 1);
-            return {
-                projection: {
-                    id: 1,
-                    [attr]: projection,
-                },
-                getData: (d) => d[attr] && getData(d[attr]),
-            };
-        }
-        else {
-            (0, assert_1.default)(rel instanceof Array);
-            const [e2, fk] = rel;
-            const { projection, getData } = makeIter(e2, idx + 1);
-            return {
-                projection: {
-                    id: 1,
-                    [attr]: {
-                        $entity: e2,
-                        data: projection,
-                    },
-                },
-                getData: (d) => d[attr] && d[attr].map(ele => getData(ele)).flat().filter(ele => !!ele),
-            };
-        }
-    };
-    return makeIter(entity, 0);
-}
-exports.destructDirectPath = destructDirectPath;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destructDirectPath = exports.destructRelationPath = void 0;
+const tslib_1 = require("tslib");
+const assert_1 = tslib_1.__importDefault(require("assert"));
+const relation_1 = require("../store/relation");
+/**
+ * 根据entity的相对path，以及定义的userRelationFilter，找到根结点对象上相应的userRelations
+ * @param schema
+ * @param entity
+ * @param path
+ * @param relationFilter
+ * @param recursive
+ */
+function destructRelationPath(schema, entity, path, relationFilter, recursive) {
+    (0, assert_1.default)(!recursive, 'recursive的情况还没处理，等跑出来再说， by Xc');
+    if (path === '') {
+        return {
+            projection: {
+                id: 1,
+                userRelation$entity: {
+                    $entity: 'userRelation',
+                    data: {
+                        id: 1,
+                        relationId: 1,
+                        relation: {
+                            id: 1,
+                            name: 1,
+                        },
+                        entity: 1,
+                        entityId: 1,
+                        userId: 1,
+                    },
+                    filter: relationFilter,
+                },
+            },
+            getData: (d) => {
+                return d.userRelation$entity;
+            },
+        };
+    }
+    const paths = path.split('.');
+    const makeIter = (e, idx) => {
+        if (idx === paths.length) {
+            return {
+                projection: {
+                    id: 1,
+                    userRelation$entity: {
+                        $entity: 'userRelation',
+                        data: {
+                            id: 1,
+                            relationId: 1,
+                            relation: {
+                                id: 1,
+                                name: 1,
+                            },
+                            entity: 1,
+                            entityId: 1,
+                            userId: 1,
+                        },
+                        filter: relationFilter,
+                    } // as ED['userRelation']['Selection']
+                },
+                getData: (d) => {
+                    return d.userRelation$entity;
+                },
+            };
+        }
+        const attr = paths[idx];
+        const rel = (0, relation_1.judgeRelation)(schema, e, attr);
+        if (rel === 2) {
+            const { projection, getData } = makeIter(attr, idx + 1);
+            return {
+                projection: {
+                    id: 1,
+                    [attr]: projection,
+                },
+                getData: (d) => d[attr] && getData(d[attr]),
+            };
+        }
+        else if (typeof rel === 'string') {
+            const { projection, getData } = makeIter(rel, idx + 1);
+            return {
+                projection: {
+                    id: 1,
+                    [attr]: projection,
+                },
+                getData: (d) => d[attr] && getData(d[attr]),
+            };
+        }
+        else {
+            (0, assert_1.default)(rel instanceof Array);
+            const [e2] = rel;
+            const { projection, getData } = makeIter(e2, idx + 1);
+            return {
+                projection: {
+                    id: 1,
+                    [attr]: {
+                        $entity: e2,
+                        data: projection,
+                    },
+                },
+                getData: (d) => d[attr] && d[attr].map(ele => getData(ele)).flat().filter(ele => !!ele),
+            };
+        }
+    };
+    return makeIter(entity, 0);
+}
+exports.destructRelationPath = destructRelationPath;
+/**
+ * 根据entity的相对path，找到对应的根结点对象上的直接userId
+ * @param schema
+ * @param entity
+ * @param path
+ * @param recursive
+ * @returns
+ */
+function destructDirectPath(schema, entity, path, recursive) {
+    (0, assert_1.default)(!recursive, '直接对象上不可能有recursive');
+    (0, assert_1.default)(path, '直接对象的路径最终要指向user对象，不可能为空');
+    const paths = path.split('.');
+    const makeIter = (e, idx) => {
+        const attr = paths[idx];
+        const rel = (0, relation_1.judgeRelation)(schema, e, attr);
+        if (idx === paths.length - 1) {
+            if (rel === 2) {
+                (0, assert_1.default)(attr === 'user');
+                return {
+                    projection: {
+                        id: 1,
+                        entity: 1,
+                        entityId: 1,
+                    },
+                    getData: (d) => {
+                        if (d) {
+                            return [{
+                                    entity: e,
+                                    entityId: d.id,
+                                    userId: d.entityId,
+                                }];
+                        }
+                    },
+                };
+            }
+            else {
+                (0, assert_1.default)(rel === 'user');
+                return {
+                    projection: {
+                        id: 1,
+                        [`${attr}Id`]: 1,
+                    },
+                    getData: (d) => {
+                        if (d) {
+                            return [{
+                                    entity: e,
+                                    entityId: d.id,
+                                    userId: d[`${attr}Id`],
+                                }];
+                        }
+                    },
+                };
+            }
+        }
+        if (rel === 2) {
+            const { projection, getData } = makeIter(attr, idx + 1);
+            return {
+                projection: {
+                    id: 1,
+                    [attr]: projection,
+                },
+                getData: (d) => d[attr] && getData(d[attr]),
+            };
+        }
+        else if (typeof rel === 'string') {
+            const { projection, getData } = makeIter(rel, idx + 1);
+            return {
+                projection: {
+                    id: 1,
+                    [attr]: projection,
+                },
+                getData: (d) => d[attr] && getData(d[attr]),
+            };
+        }
+        else {
+            (0, assert_1.default)(rel instanceof Array);
+            const [e2, fk] = rel;
+            const { projection, getData } = makeIter(e2, idx + 1);
+            return {
+                projection: {
+                    id: 1,
+                    [attr]: {
+                        $entity: e2,
+                        data: projection,
+                    },
+                },
+                getData: (d) => d[attr] && d[attr].map(ele => getData(ele)).flat().filter(ele => !!ele),
+            };
+        }
+    };
+    return makeIter(entity, 0);
+}
+exports.destructDirectPath = destructDirectPath;

package/package.json

@@ -1,51 +1,51 @@
-{
-    "name": "oak-domain",
-    "version": "4.2.2",
-    "author": {
-        "name": "XuChang"
-    },
-    "scripts": {
-        "make:domain": "ts-node scripts/make.ts",
-        "build": "tsc",
-        "prebuild": "npm run make:domain",
-        "test": "ts-node test/test.ts"
-    },
-    "files": [
-        "lib/**/*",
-        "src/entities/*"
-    ],
-    "main": "lib/index",
-    "devDependencies": {
-        "@babel/cli": "^7.12.13",
-        "@babel/core": "^7.12.13",
-        "@babel/plugin-proposal-class-properties": "^7.12.13",
-        "@babel/preset-env": "^7.12.13",
-        "@babel/preset-typescript": "^7.12.13",
-        "@types/assert": "^1.5.6",
-        "@types/cross-spawn": "^6.0.2",
-        "@types/fs-extra": "^9.0.13",
-        "@types/lodash": "^4.14.182",
-        "@types/mocha": "^8.2.0",
-        "@types/node": "^20.6.1",
-        "@types/node-schedule": "^2.1.0",
-        "@types/react": "^17.0.2",
-        "@types/uuid": "^8.3.0",
-        "@types/wechat-miniprogram": "^3.4.1",
-        "assert": "^2.0.0",
-        "cross-env": "^7.0.2",
-        "cross-spawn": "^7.0.3",
-        "fs-extra": "^10.0.0",
-        "lodash": "^4.17.21",
-        "mocha": "^8.2.1",
-        "node-watch": "^0.7.4",
-        "ts-node": "^10.9.1",
-        "tslib": "^2.4.0",
-        "typescript": "^5.2.2"
-    },
-    "dependencies": {
-        "dayjs": "^1.11.9",
-        "node-schedule": "^2.1.1",
-        "uuid": "^9.0.0",
-        "webidl-conversions": "^5.0.0"
-    }
-}
+{
+    "name": "oak-domain",
+    "version": "4.2.4",
+    "author": {
+        "name": "XuChang"
+    },
+    "scripts": {
+        "make:domain": "ts-node scripts/make.ts",
+        "build": "tsc",
+        "prebuild": "npm run make:domain",
+        "test": "ts-node test/test.ts"
+    },
+    "files": [
+        "lib/**/*",
+        "src/entities/*"
+    ],
+    "main": "lib/index",
+    "devDependencies": {
+        "@babel/cli": "^7.12.13",
+        "@babel/core": "^7.12.13",
+        "@babel/plugin-proposal-class-properties": "^7.12.13",
+        "@babel/preset-env": "^7.12.13",
+        "@babel/preset-typescript": "^7.12.13",
+        "@types/assert": "^1.5.6",
+        "@types/cross-spawn": "^6.0.2",
+        "@types/fs-extra": "^9.0.13",
+        "@types/lodash": "^4.14.182",
+        "@types/mocha": "^8.2.0",
+        "@types/node": "^20.6.1",
+        "@types/node-schedule": "^2.1.0",
+        "@types/react": "^17.0.2",
+        "@types/uuid": "^8.3.0",
+        "@types/wechat-miniprogram": "^3.4.1",
+        "assert": "^2.0.0",
+        "cross-env": "^7.0.2",
+        "cross-spawn": "^7.0.3",
+        "fs-extra": "^10.0.0",
+        "lodash": "^4.17.21",
+        "mocha": "^8.2.1",
+        "node-watch": "^0.7.4",
+        "ts-node": "^10.9.1",
+        "tslib": "^2.4.0",
+        "typescript": "^5.2.2"
+    },
+    "dependencies": {
+        "dayjs": "^1.11.9",
+        "node-schedule": "^2.1.1",
+        "uuid": "^9.0.0",
+        "webidl-conversions": "^5.0.0"
+    }
+}

package/src/entities/ActionAuth.ts

@@ -1,41 +1,41 @@
-import { EntityShape } from '../types/Entity';
-import { Schema as Relation } from './Relation';
-import { EntityDesc } from '../types/EntityDesc';
-import { Schema as Path } from './Path';
-
-type Actions = string[];
-
-export interface Schema extends EntityShape {
-    relation?: Relation;
-    path: Path;
-    deActions: Actions;
-};
-
-const entityDesc: EntityDesc<Schema> = {
-    locales: {
-        zh_CN: {
-            name: '用户授权',
-            attr: {
-                relation: '关系',
-                path: '路径',
-                deActions: '目标对象动作',
-            },
-        },
-    },
-    indexes: [
-        {
-            name: 'index_relation_path',
-            attributes: [
-                {
-                    name: 'relation',
-                },
-                {
-                    name: 'path',
-                }
-            ],
-            config: {
-                unique: true,
-            },
-        },
-    ],
-};
+import { EntityShape } from '../types/Entity';
+import { Schema as Relation } from './Relation';
+import { EntityDesc } from '../types/EntityDesc';
+import { Schema as Path } from './Path';
+
+type Actions = string[];
+
+export interface Schema extends EntityShape {
+    relation?: Relation;
+    path: Path;
+    deActions: Actions;
+};
+
+const entityDesc: EntityDesc<Schema> = {
+    locales: {
+        zh_CN: {
+            name: '用户授权',
+            attr: {
+                relation: '关系',
+                path: '路径',
+                deActions: '目标对象动作',
+            },
+        },
+    },
+    indexes: [
+        {
+            name: 'index_relation_path',
+            attributes: [
+                {
+                    name: 'relation',
+                },
+                {
+                    name: 'path',
+                }
+            ],
+            config: {
+                unique: true,
+            },
+        },
+    ],
+};