@ldsg/rrm-query-resource-records 0.3.41 → 0.3.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ldsg/rrm-query-resource-records",
-  "version": "0.3.41",
+  "version": "0.3.43",
   "description": "",
   "keywords": [],
   "license": "MIT",
@@ -14,7 +14,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@ldsg/rrm-utils": "0.3.41"
+    "@ldsg/rrm-utils": "0.3.43"
   },
   "devDependencies": {
     "@types/jest": "^29.5.2",
@@ -29,12 +29,12 @@
     "ts-jest": "^29.1.5",
     "ts-node": "^10.9.2",
     "typescript": "^5.8.3",
-    "@ldsg/application": "0.3.41",
-    "@ldsg/graphql": "0.3.41",
-    "@ldsg/object": "0.3.41",
-    "@ldsg/object-field": "0.3.41",
-    "@ldsg/types": "0.3.41",
-    "@ldsg/workflow": "0.3.41"
+    "@ldsg/application": "0.3.43",
+    "@ldsg/graphql": "0.3.43",
+    "@ldsg/object": "0.3.43",
+    "@ldsg/object-field": "0.3.43",
+    "@ldsg/types": "0.3.43",
+    "@ldsg/workflow": "0.3.43"
   },
   "scripts": {
     "build": "tsc --project tsconfig.build.json",

package/dist/mutate-resource-records.d.ts

@@ -1,24 +0,0 @@
-import { WorkflowNodeTypeResourceExtendedHandler } from "@ldsg/workflow-node-type";
-interface ResourceRecord {
-    id: string;
-    kind: string;
-    parentId?: string;
-    settings: Record<string, any>;
-}
-interface CreatedResourceRecord extends ResourceRecord {
-    originalId: string;
-}
-type ResourceRecords = ResourceRecord[];
-interface InputVariables {
-    ownerId: string;
-    createResourceRecords?: ResourceRecords;
-    updateResourceRecords?: ResourceRecords;
-}
-interface OutputVariables {
-    createdResourceRecords?: CreatedResourceRecord[];
-    updatedResourceRecords?: ResourceRecords;
-}
-export type MutateResourceRecords = WorkflowNodeTypeResourceExtendedHandler<InputVariables, OutputVariables>;
-export declare const mutateResourceRecords: MutateResourceRecords;
-export {};
-//# sourceMappingURL=mutate-resource-records.d.ts.map

package/dist/mutate-resource-records.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mutate-resource-records.d.ts","sourceRoot":"","sources":["../src/mutate-resource-records.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uCAAuC,EAAE,MAAM,0BAA0B,CAAC;AAkCnF,UAAU,cAAc;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;CAC/B;AAED,UAAU,qBAAsB,SAAQ,cAAc;IACpD,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,KAAK,eAAe,GAAG,cAAc,EAAE,CAAC;AAExC,UAAU,cAAc;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,qBAAqB,CAAC,EAAE,eAAe,CAAC;IACxC,qBAAqB,CAAC,EAAE,eAAe,CAAC;CACzC;AAED,UAAU,eAAe;IACvB,sBAAsB,CAAC,EAAE,qBAAqB,EAAE,CAAC;IACjD,sBAAsB,CAAC,EAAE,eAAe,CAAC;CAC1C;AA4DD,MAAM,MAAM,qBAAqB,GAAG,uCAAuC,CACzE,cAAc,EACd,eAAe,CAChB,CAAC;AAEF,eAAO,MAAM,qBAAqB,EAAE,qBAklBnC,CAAC"}

package/dist/mutate-resource-records.js

@@ -1,496 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.mutateResourceRecords = void 0;
-const utils_1 = require("@ldsg/utils");
-const lodash_1 = __importDefault(require("lodash"));
-const mongoose_1 = __importDefault(require("mongoose"));
-const countRootResourceRecords = (params) => {
-    const { resourceRecords } = params;
-    const rootResourceRecords = lodash_1.default.filter(resourceRecords, (resourceRecord) => {
-        return !resourceRecord.parentId;
-    });
-    const count = rootResourceRecords.length;
-    const res = {
-        count,
-        rootResourceRecords,
-    };
-    return res;
-};
-/**
- * 拓扑排序
- * 以拓扑序（父节点优先于子节点）处理，主要是为了计算 path，这样可以确保父级 path 先计算出
- */
-function topologicalSort(records) {
-    const sorted = [];
-    const visited = new Set();
-    const ids = new Set(records.map((r) => r.id));
-    const byId = new Map(records.map((r) => [r.id, r]));
-    function visit(id) {
-        if (visited.has(id))
-            return;
-        visited.add(id);
-        const record = byId.get(id);
-        if ((record === null || record === void 0 ? void 0 : record.parentId) && ids.has(record.parentId)) {
-            visit(record.parentId);
-        }
-        const r = byId.get(id);
-        if (r)
-            sorted.push(r);
-    }
-    for (const record of records) {
-        visit(record.id);
-    }
-    return sorted;
-}
-const mutateResourceRecords = async (params) => {
-    var _a, _b;
-    const { variables, handlerResourceInstance } = params;
-    const mutatedAt = new Date();
-    const { ownerId, createResourceRecords = [], updateResourceRecords = [] } = variables;
-    if (!ownerId) {
-        throw new Error("owner id is required when updating resource records");
-    }
-    const getFilteredResourceRes = handlerResourceInstance.getFilteredResource({
-        kind: "tables",
-    });
-    const tablesResource = getFilteredResourceRes.resource;
-    const { ResourceRecord, ResourceRecordVersion, ResourceRecordChange } = tablesResource.mongooseModels;
-    const createdResourceRecords = [];
-    const updatedResourceRecords = [];
-    const newResourceRecordDocuments = [];
-    const updateOps = [];
-    /**
-     * 资源ID映射
-     */
-    let resourceIdMap = {};
-    /**
-     * 根资源ID
-     * 一次变更资源记录操作仅操作同一资源树中的资源
-     */
-    let rootResourceId;
-    /**
-     * 是否拟创建根资源记录
-     */
-    let isCreateRootResourceRecord = false;
-    /**
-     * 旧资源ID对新资源ID映射
-     * 仅新增加资源ID才会被记录
-     */
-    const oldIdToNewIdMap = {};
-    const { count: createRootResourceRecordsCount, rootResourceRecords: createRootResourceRecords } = countRootResourceRecords({
-        resourceRecords: createResourceRecords,
-    });
-    const { count: updateRootResourceRecordsCount, rootResourceRecords: updateRootResourceRecords } = countRootResourceRecords({
-        resourceRecords: updateResourceRecords,
-    });
-    if (createRootResourceRecordsCount + updateRootResourceRecordsCount > 1) {
-        console.info("mutateResourceRecords createRootResourceRecordsCount", createRootResourceRecordsCount);
-        console.info("mutateResourceRecords updateRootResourceRecordsCount", updateRootResourceRecordsCount);
-        console.info("mutateResourceRecords createRootResourceRecords", createRootResourceRecords);
-        console.info("mutateResourceRecords updateRootResourceRecords", updateRootResourceRecords);
-        throw new Error("创建与更新资源记录中只能有一个顶级资源记录");
-    }
-    /**
-     * 1. 找出找创建根资源ID
-     * 2. 找出全部已存在应用资源与版本（仅非新建应用时执行）
-     * 3. 批量处理拟创建资源记录文档
-     * 4. 批量处理拟更新资源记录（仅非新建应用时执行）
-     * 5. 批量执行写入
-     */
-    /**
-     * 1. 找出找创建根资源ID
-     */
-    {
-        if (createRootResourceRecordsCount === 1) {
-            /**
-             * 拟创建资源中包含根资源时，说明是创建新应用，此时不应包含旧应用
-             */
-            isCreateRootResourceRecord = true;
-            const createRootResourceRecord = createResourceRecords.find((r) => !r.parentId);
-            if (!createRootResourceRecord) {
-                throw new Error("invalid create root resource record");
-            }
-            const oldResourceId = createRootResourceRecord.id;
-            if (!oldResourceId) {
-                throw new Error("invalid create root resource id");
-            }
-            const rootNewId = new mongoose_1.default.Types.ObjectId().toString();
-            oldIdToNewIdMap[oldResourceId] = rootNewId;
-            rootResourceId = rootNewId;
-            if (updateResourceRecords.length) {
-                throw new Error("如果创建资源记录中有一个顶级资源记录（说明是新应用），那么就不能存在任何更新资源记录");
-            }
-        }
-        else {
-            /**
-             * 拟创建资源中不包含根资源时，说明是变更旧应用资源，此时可以通过找出任一旧资源并根据 path 找出根资源
-             */
-            /**
-             * 任一已存在资源ID
-             */
-            let anyExistingResourceId;
-            if (updateResourceRecords.length > 0) {
-                /**
-                 * 拟更新资源中不包含根资源但有多个资源时，通过任一拟更新资源找出根资源
-                 */
-                const anyExistingResourceRecord = updateResourceRecords[0];
-                anyExistingResourceId = anyExistingResourceRecord.id;
-            }
-            else if (createResourceRecords.length > 0) {
-                /**
-                 * 拟创建资源中不包含根资源但有多个资源时，找出拟创建资源中最顶级资源，最顶级资源的父资源应是已存在的资源，通过此已存在的资源找出根资源
-                 */
-                const createResourceIds = new Set(createResourceRecords.map((r) => r.id));
-                let currentResourceRecord = createResourceRecords[0];
-                let parentId = currentResourceRecord.parentId;
-                while (parentId && createResourceIds.has(parentId)) {
-                    const findRes = createResourceRecords.find((r) => r.id === parentId);
-                    if (!findRes)
-                        break;
-                    currentResourceRecord = findRes;
-                    parentId = currentResourceRecord.parentId;
-                }
-                anyExistingResourceId = parentId;
-            }
-            if (!anyExistingResourceId || !mongoose_1.default.Types.ObjectId.isValid(anyExistingResourceId)) {
-                throw new Error("invalid root resource id");
-            }
-            const findByIdRes = await ResourceRecord.findById(anyExistingResourceId);
-            if (!findByIdRes) {
-                throw new Error("invalid any existing resource id");
-            }
-            const { path } = findByIdRes !== null && findByIdRes !== void 0 ? findByIdRes : {};
-            if (!path) {
-                throw new Error("invalid path");
-            }
-            rootResourceId = path.split("/")[1];
-        }
-        if (!rootResourceId || !mongoose_1.default.Types.ObjectId.isValid(rootResourceId)) {
-            throw new Error("invalid root resource id");
-        }
-    }
-    /**
-     * 已存在资源ID对资源记录文档映射
-     */
-    let existingResourceIdToResourceRecordDocumentMap;
-    /**
-     * 资源记录版本ID集合
-     */
-    let resourceRecordVersionIdSet = new Set();
-    /**
-     * 已存在资源ID对版本ID映射
-     */
-    let existingResourceIdToVersionId = new Map();
-    /**
-     * 已存在资源ID对资源路径映射
-     */
-    const existingResourceIdToPathMap = {};
-    /**
-     * 2. 找出全部已存在应用资源与版本（仅非新建应用时执行）
-     */
-    if (!isCreateRootResourceRecord) {
-        /**
-         * 应用树形资源记录文档
-         */
-        const applicationTreeResourceRecordDocuments = await ResourceRecord.find({
-            path: { $regex: new RegExp(`^/${rootResourceId}`) },
-        });
-        existingResourceIdToResourceRecordDocumentMap = new Map(applicationTreeResourceRecordDocuments.map((r) => [r._id.toString(), r]));
-        for (const [id, resourceRecordDocument] of existingResourceIdToResourceRecordDocumentMap) {
-            existingResourceIdToPathMap[id] = resourceRecordDocument.path;
-        }
-        const applicationTreeResourceRecordDocumentActiveVersionIds = applicationTreeResourceRecordDocuments
-            .map((r) => r.activeVersionId)
-            .filter((id) => id != null);
-        const resourceRecordVersionDocuments = await ResourceRecordVersion.find({
-            _id: { $in: applicationTreeResourceRecordDocumentActiveVersionIds },
-        });
-        resourceRecordVersionIdSet = new Set(resourceRecordVersionDocuments.map((v) => v._id.toString()));
-        for (const applicationTreeResourceRecordDocument of applicationTreeResourceRecordDocuments) {
-            const { id, activeVersionId } = applicationTreeResourceRecordDocument;
-            /**
-             * 有的版本ID可能不存在，在此处不报错主要是为了提高容错性，如：
-             * 当资源的 activeVersionId 被误删或相应的资源版本被清空时，应用需要可以正常运转。
-             */
-            if (activeVersionId && resourceRecordVersionIdSet.has(activeVersionId.toString())) {
-                existingResourceIdToVersionId.set(id, activeVersionId.toString());
-            }
-        }
-        /**
-         * 校验拟更新资源父级ID与类型是否一致
-         */
-        for (const resourceRecord of updateResourceRecords) {
-            const { id: resourceId } = resourceRecord;
-            const resourceRecordDocument = existingResourceIdToResourceRecordDocumentMap.get(resourceId);
-            if (!resourceRecordDocument) {
-                throw new Error(`Resource record not found: ${resourceId}`);
-            }
-            if (resourceRecordDocument.ownerId !== ownerId) {
-                throw new Error(`Resource record ${resourceId} does not belong to the current user`);
-            }
-            const resourceRecordDocumentParentIdStr = ((_a = resourceRecordDocument.parentId) === null || _a === void 0 ? void 0 : _a.toString()) || "";
-            const resourceRecordParentId = resourceRecord.parentId || "";
-            if (resourceRecordParentId !== resourceRecordDocumentParentIdStr) {
-                throw new Error(`Resource record ${resourceId} parentId mismatch`);
-            }
-            if (resourceRecord.kind !== resourceRecordDocument.kind) {
-                throw new Error(`Resource record ${resourceId} kind mismatch`);
-            }
-        }
-    }
-    /**
-     * 已替换 ID 后的资源设置快照
-     * 当无新建资源时，映射表为空，直接使用原始设置
-     */
-    let newResourceIdToSettings;
-    /**
-     * 3. 批量处理拟创建资源记录文档
-     */
-    if (createResourceRecords.length) {
-        for (const resourceRecord of createResourceRecords) {
-            const { id: oldResourceId } = resourceRecord;
-            /**
-             * 这里判断一下是否已经存在，主要是为了避免替换拟创建根资源ID
-             */
-            if (!oldIdToNewIdMap[oldResourceId]) {
-                oldIdToNewIdMap[oldResourceId] = new mongoose_1.default.Types.ObjectId().toString();
-            }
-        }
-        /**
-         * 一次性替换所有资源记录 settings 中的旧 ID
-         */
-        const oldResourceIdToSettings = {};
-        const allOldResourceRecords = [...createResourceRecords, ...updateResourceRecords];
-        for (const r of allOldResourceRecords) {
-            oldResourceIdToSettings[r.id] = r.settings;
-        }
-        const replaceResourceIdsRes = (0, utils_1.replaceResourceIds)({
-            source: oldResourceIdToSettings,
-            oldResourceIdToNewResourceIdMap: oldIdToNewIdMap,
-        });
-        newResourceIdToSettings = replaceResourceIdsRes.replacement;
-        const topologicalSortedCreateResourceRecords = topologicalSort(createResourceRecords);
-        const newResourceIdToPathMap = {};
-        for (const resourceRecord of topologicalSortedCreateResourceRecords) {
-            const { id: oldResourceId, parentId: oldParentId, kind } = resourceRecord;
-            const newResourceId = oldIdToNewIdMap[oldResourceId];
-            const newResourceIdObject = new mongoose_1.default.Types.ObjectId(newResourceId);
-            let parentId = oldParentId ? oldIdToNewIdMap[oldParentId] || oldParentId : undefined;
-            if (parentId && !mongoose_1.default.Types.ObjectId.isValid(parentId)) {
-                throw new Error("invalid parent id");
-            }
-            const resourceSettings = newResourceIdToSettings[newResourceId];
-            let path = "";
-            /**
-             * 为新资源ID写入资源路径
-             */
-            {
-                if (parentId) {
-                    const parentPath = newResourceIdToPathMap[parentId] || existingResourceIdToPathMap[parentId];
-                    if (!parentPath) {
-                        throw new Error("invalid parent path");
-                    }
-                    path = `${parentPath}/${newResourceId}`;
-                }
-                else {
-                    path = `/${newResourceId}`;
-                }
-                newResourceIdToPathMap[newResourceId] = path;
-            }
-            const newVersionId = new mongoose_1.default.Types.ObjectId();
-            newResourceRecordDocuments.push({
-                createdAt: mutatedAt,
-                updatedAt: mutatedAt,
-                _id: newResourceIdObject,
-                kind,
-                parentId: parentId ? new mongoose_1.default.Types.ObjectId(parentId) : undefined,
-                path,
-                settings: resourceSettings,
-                ownerId,
-                activeVersionId: newVersionId,
-            });
-            resourceIdMap[newResourceId] = {
-                versionId: newVersionId.toString(),
-                isNewResource: true,
-                isNewVersion: true,
-                isNeedToCreateVersion: true,
-                settings: resourceSettings,
-            };
-            createdResourceRecords.push({
-                id: newResourceId,
-                originalId: oldResourceId,
-                kind,
-                parentId,
-                settings: resourceSettings,
-            });
-        }
-    }
-    /**
-     * 4. 批量处理拟更新资源记录（仅非新建应用时执行）
-     */
-    if (!isCreateRootResourceRecord) {
-        if (!existingResourceIdToResourceRecordDocumentMap) {
-            throw new Error("invalid existing resource id to resource record document map");
-        }
-        for (const resourceRecord of updateResourceRecords) {
-            const { id: resourceId, parentId, kind, settings: oldResourceSettings } = resourceRecord;
-            const resourceRecordDocument = existingResourceIdToResourceRecordDocumentMap.get(resourceId);
-            if (!resourceRecordDocument) {
-                throw new Error("invalid resource record document");
-            }
-            const resourceSettings = (_b = newResourceIdToSettings === null || newResourceIdToSettings === void 0 ? void 0 : newResourceIdToSettings[resourceId]) !== null && _b !== void 0 ? _b : oldResourceSettings;
-            const isSettingsUnchanged = lodash_1.default.isEqual(resourceRecordDocument.settings, resourceSettings);
-            if (isSettingsUnchanged) {
-                const existingVersionId = existingResourceIdToVersionId.get(resourceId);
-                if (existingVersionId) {
-                    resourceIdMap[resourceId] = {
-                        versionId: existingVersionId,
-                        isNewResource: false,
-                        isNewVersion: false,
-                        isNeedToCreateVersion: false,
-                        settings: resourceSettings,
-                    };
-                }
-                else {
-                    const newVersionId = new mongoose_1.default.Types.ObjectId();
-                    resourceIdMap[resourceId] = {
-                        versionId: newVersionId.toString(),
-                        isNewResource: false,
-                        isNewVersion: false,
-                        isNeedToCreateVersion: true,
-                        settings: resourceSettings,
-                    };
-                }
-            }
-            else {
-                const newVersionId = new mongoose_1.default.Types.ObjectId();
-                updateOps.push({
-                    updateOne: {
-                        filter: { _id: resourceRecordDocument._id },
-                        update: {
-                            $set: {
-                                settings: resourceSettings,
-                                activeVersionId: newVersionId,
-                                updatedAt: mutatedAt,
-                            },
-                        },
-                    },
-                });
-                resourceIdMap[resourceId] = {
-                    versionId: newVersionId.toString(),
-                    isNewResource: false,
-                    isNewVersion: true,
-                    isNeedToCreateVersion: true,
-                    settings: resourceSettings,
-                };
-            }
-            updatedResourceRecords.push({
-                id: resourceId,
-                kind,
-                parentId,
-                settings: resourceSettings,
-            });
-        }
-        /**
-         * 本次改变的资源ID集合
-         */
-        const changedRecordIdSet = new Set([
-            ...createResourceRecords.map((r) => oldIdToNewIdMap[r.id]),
-            ...updateResourceRecords.map((r) => r.id),
-        ]);
-        for (const [resourceId, resourceRecordDocument,] of existingResourceIdToResourceRecordDocumentMap) {
-            const { settings } = resourceRecordDocument;
-            /**
-             * 已在本次改变的资源ID集合中的资源ID就跳过
-             */
-            if (changedRecordIdSet.has(resourceId))
-                continue;
-            const existingVersionId = existingResourceIdToVersionId.get(resourceId);
-            if (existingVersionId) {
-                resourceIdMap[resourceId] = {
-                    versionId: existingVersionId,
-                    isNewResource: false,
-                    isNewVersion: false,
-                    isNeedToCreateVersion: false,
-                    settings,
-                };
-            }
-            else {
-                /**
-                 * 理论上已存在在资源ID应该存在相应的版本，但为了容错以提升应用健壮性，当已存在资源的版本丢失时，创建新版本
-                 */
-                const newVersionId = new mongoose_1.default.Types.ObjectId();
-                resourceIdMap[resourceId] = {
-                    versionId: newVersionId.toString(),
-                    isNewResource: false,
-                    isNewVersion: false,
-                    isNeedToCreateVersion: true,
-                    settings,
-                };
-            }
-        }
-    }
-    /**
-     * 5. 批量执行写入
-     */
-    {
-        /**
-         * 批量创建资源记录
-         */
-        if (newResourceRecordDocuments.length > 0) {
-            await ResourceRecord.insertMany(newResourceRecordDocuments);
-        }
-        /**
-         * 批量更新资源记录
-         */
-        if (updateOps.length > 0) {
-            await ResourceRecord.bulkWrite(updateOps);
-        }
-        /**
-         * 批量创建版本
-         */
-        {
-            const newVersionDocuments = [];
-            for (const [resourceId, { versionId, isNeedToCreateVersion, settings }] of Object.entries(resourceIdMap)) {
-                /**
-                 * 当无需要创建版本时，跳过执行，一般是因为版本已存在。
-                 */
-                if (!isNeedToCreateVersion)
-                    continue;
-                newVersionDocuments.push({
-                    createdAt: mutatedAt,
-                    _id: versionId,
-                    resourceId,
-                    settings,
-                });
-            }
-            if (newVersionDocuments.length > 0) {
-                await ResourceRecordVersion.insertMany(newVersionDocuments);
-            }
-        }
-        /**
-         * 创建资源记录变更
-         */
-        if (Object.keys(resourceIdMap).length > 0) {
-            const reducedResourceIdMap = lodash_1.default.mapValues(resourceIdMap, (value) => lodash_1.default.pick(value, ["versionId", "isNewResource", "isNewVersion"]));
-            await ResourceRecordChange.create({
-                createdAt: mutatedAt,
-                rootResourceId,
-                resourceIdMap: reducedResourceIdMap,
-                remark: "",
-            });
-        }
-    }
-    const resVariables = {
-        createdResourceRecords,
-        updatedResourceRecords,
-    };
-    const res = {
-        variables: resVariables,
-    };
-    return res;
-};
-exports.mutateResourceRecords = mutateResourceRecords;

package/dist/utils/query-resource-records/index.d.ts

@@ -1,3 +0,0 @@
-import { QueryResourceRecords } from "./types";
-export declare const queryResourceRecords: QueryResourceRecords;
-//# sourceMappingURL=index.d.ts.map

package/dist/utils/query-resource-records/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/utils/query-resource-records/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,oBAAoB,EAA4B,MAAM,SAAS,CAAC;AAEzE,eAAO,MAAM,oBAAoB,EAAE,oBA6BlC,CAAC"}

package/dist/utils/query-resource-records/index.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.queryResourceRecords = void 0;
-const types_1 = require("./types");
-const queryResourceRecords = async (params) => {
-    const { variables, handlerResourceInstance } = params;
-    const { rootResourceId, purpose = types_1.Purpose.RUNTIME } = variables;
-    const getFilteredResourceRes = handlerResourceInstance.getFilteredResource({
-        kind: "tables",
-    });
-    const tablesResource = getFilteredResourceRes.resource;
-    const { ResourceRecord, ResourceRecordVersion, ResourceRecordChange } = tablesResource.mongooseModels;
-    const resourceRecords = [];
-    const resVariables = {
-        resourceRecords,
-    };
-    const res = {
-        variables: resVariables,
-    };
-    return res;
-};
-exports.queryResourceRecords = queryResourceRecords;

package/dist/utils/query-resource-records/types.d.ts

@@ -1,35 +0,0 @@
-import { ResourceRecords } from "@ldsg/types";
-import { WorkflowNodeTypeResourceExtendedHandler } from "@ldsg/workflow-node-type";
-/**
- * 用途
- */
-export declare enum Purpose {
-    /**
-     * 编辑态
-     */
-    EDIT = "edit",
-    /**
-     * 运行态
-     */
-    RUNTIME = "runtime"
-}
-export interface InputVariables {
-    /**
-     * 根资源 ID
-     * 必选
-     * 用于限定资源记录查询范围
-     */
-    rootResourceId: string;
-    /**
-     * 用途
-     * 必选
-     * 默认值：runtime
-     * 用于表明资源记录查询用途
-     */
-    purpose?: Purpose;
-}
-export interface OutputVariables {
-    resourceRecords?: ResourceRecords;
-}
-export type QueryResourceRecords = WorkflowNodeTypeResourceExtendedHandler<InputVariables, OutputVariables>;
-//# sourceMappingURL=types.d.ts.map

package/dist/utils/query-resource-records/types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/utils/query-resource-records/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,OAAO,EAAE,uCAAuC,EAAE,MAAM,0BAA0B,CAAC;AAEnF;;GAEG;AACH,oBAAY,OAAO;IACjB;;OAEG;IACH,IAAI,SAAS;IAEb;;OAEG;IACH,OAAO,YAAY;CACpB;AAED,MAAM,WAAW,cAAc;IAC7B;;;;OAIG;IACH,cAAc,EAAE,MAAM,CAAC;IAEvB;;;;;OAKG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,eAAe,CAAC,EAAE,eAAe,CAAC;CACnC;AAED,MAAM,MAAM,oBAAoB,GAAG,uCAAuC,CACxE,cAAc,EACd,eAAe,CAChB,CAAC"}

package/dist/utils/query-resource-records/types.js

@@ -1,17 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Purpose = void 0;
-/**
- * 用途
- */
-var Purpose;
-(function (Purpose) {
-    /**
-     * 编辑态
-     */
-    Purpose["EDIT"] = "edit";
-    /**
-     * 运行态
-     */
-    Purpose["RUNTIME"] = "runtime";
-})(Purpose || (exports.Purpose = Purpose = {}));