@steedos/service-metadata-database 3.0.0-beta.8

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@steedos/service-metadata-database",
+  "version": "3.0.0-beta.8",
+  "main": "package.service.js",
+  "scripts": {
+    "build": "rm -rf ./lib && tsc"
+  },
+  "dependencies": {
+    "@steedos/metadata-registrar": "3.0.0-beta.8",
+    "@steedos/objectql": "3.0.0-beta.8",
+    "lodash": "^4.17.21"
+  },
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "private": false,
+  "publishConfig": {
+    "access": "public"
+  },
+  "gitHead": "723d92765db5342a374c7aacb5b835e69f77ca4b"
+}

package/package.service.js

@@ -0,0 +1,10 @@
+/*
+ * @Author: baozhoutao@steedos.com
+ * @Date: 2024-11-22 16:45:46
+ * @LastEditors: baozhoutao@steedos.com
+ * @LastEditTime: 2024-12-05 19:29:41
+ * @Description: 
+ */
+
+const service = require("./lib/index.js");
+module.exports = service;

package/src/constants.ts

@@ -0,0 +1 @@
+export const DB_OBJECT_SERVICE_NAME = "~database-objects";

package/src/handles/apps.ts

@@ -0,0 +1,28 @@
+import { addAppConfig, getObject, removeApp } from "@steedos/objectql";
+import { BaseHandle } from "./base";
+import { DB_OBJECT_SERVICE_NAME } from "../constants";
+
+export class AppsHandle extends BaseHandle {
+  constructor() {
+    super("apps");
+  }
+
+  async init() {
+    const dbApps = await getObject("apps").directFind();
+    for (const dbApp of dbApps) {
+      await this.inserted(dbApp);
+    }
+  }
+
+  async inserted(data) {
+    return addAppConfig(data, DB_OBJECT_SERVICE_NAME);
+  }
+
+  async updated(data) {
+    return addAppConfig(data, DB_OBJECT_SERVICE_NAME);
+  }
+
+  async deleted(data) {
+    return removeApp(data._id);
+  }
+}

package/src/handles/base.ts

@@ -0,0 +1,48 @@
+export type ActionData = {
+  name: string;
+  [key: string]: unknown;
+};
+
+export class BaseHandle {
+  type: string;
+
+  constructor(type: string) {
+    this.type = type;
+  }
+
+  async init() {
+    console.log(`todo: ${this.type} init`);
+  }
+
+  async handleAction(
+    action: "inserted" | "updated" | "deleted",
+    data: ActionData,
+  ) {
+    console.log("BaseHandle handleAction", action, JSON.stringify(data));
+    switch (action) {
+      case "inserted":
+        await this.inserted(data);
+        break;
+      case "updated":
+        await this.updated(data);
+        break;
+      case "deleted":
+        await this.deleted(data);
+        break;
+      default:
+        console.warn(`未知的操作类型: ${action}`);
+    }
+  }
+
+  async inserted(data: ActionData) {
+    console.log(`todo: ${this.type} inserted`, data);
+  }
+
+  async updated(data: ActionData) {
+    console.log(`todo: ${this.type} updated`, data);
+  }
+
+  async deleted(data: ActionData) {
+    console.log(`todo: ${this.type} deleted`, data);
+  }
+}

package/src/handles/index.ts

@@ -0,0 +1,5 @@
+export * from "./objects";
+export * from "./apps";
+export * from "./tabs";
+export * from "./triggers";
+export * from "./share_rules";

package/src/handles/objects.ts

@@ -0,0 +1,102 @@
+import { getObject } from "@steedos/objectql";
+import * as _ from "lodash";
+import { MetadataRegister } from "@steedos/metadata-registrar";
+import { DB_OBJECT_SERVICE_NAME } from "../constants";
+import { BaseHandle } from "./base";
+
+export class ObjectsHandle extends BaseHandle {
+  constructor() {
+    super("objects");
+  }
+
+  async init() {
+    const dbObjects = await getObject("objects").directFind({
+      fields: ["name"],
+    });
+    for (const dbObject of dbObjects) {
+      await this.handle(dbObject.name);
+    }
+  }
+
+  async inserted(data) {
+    return this.handle(data.name);
+  }
+
+  async updated(data) {
+    return this.handle(data.name);
+  }
+
+  async deleted(data) {
+    broker.call("objects.removeConfig", {
+      objectName: data.name,
+    });
+  }
+
+  async handle(objectName) {
+    try {
+      console.log("ObjectHandle handle", objectName);
+      const records = await getObject("objects").directFind({
+        filters: ["name", "=", objectName],
+      });
+      if (!records || records.length === 0) {
+        return null;
+      }
+
+      const record = records[0];
+
+      // 查询字段
+      const fieldRecords = await getObject("object_fields").directFind({
+        filters: ["object", "=", objectName],
+      });
+      const fields = {};
+      _.map(fieldRecords, (field) => {
+        fields[field.name] = field;
+      });
+
+      // 查询按钮
+      const btnRecords = await getObject("object_actions").directFind({
+        filters: ["object", "=", objectName],
+      });
+
+      const actions = {};
+      _.map(btnRecords, (action) => {
+        actions[action.name] = action;
+      });
+
+      // 查询列表视图
+      const lvRecords = await getObject("object_listviews").directFind({
+        filters: ["object_name", "=", objectName],
+      });
+
+      const list_views = {};
+      _.map(lvRecords, (listview) => {
+        list_views[listview.name] = listview;
+      });
+
+      // console.log(
+      //   `addObjectConfig record`,
+      //   JSON.stringify(
+      //     Object.assign({}, record, {
+      //       isMain: true,
+      //       fields,
+      //       actions,
+      //       list_views,
+      //     }),
+      //   ),
+      // );
+      await MetadataRegister.addObjectConfig(
+        DB_OBJECT_SERVICE_NAME,
+        Object.assign({}, record, {
+          isMain: true,
+          fields,
+          actions,
+          list_views,
+        }),
+      );
+      broker.broadcast("$packages.statisticsActivatedPackages", {});
+    } catch (error) {
+      console.error(error);
+      throw error;
+    }
+  }
+}

package/src/handles/restriction_rules.ts

@@ -0,0 +1,40 @@
+import { registerRestrictionRules, getObject } from "@steedos/objectql";
+import { BaseHandle } from "./base";
+import { DB_OBJECT_SERVICE_NAME } from "../constants";
+
+export class RestrictionRulesHandle extends BaseHandle {
+  constructor() {
+    super("restriction_rules");
+  }
+
+  async init() {
+    const dbRecords = await getObject("restriction_rules").directFind();
+    for (const dbRecord of dbRecords) {
+      await this.inserted(dbRecord);
+    }
+  }
+
+  async inserted(data) {
+    return registerRestrictionRules.register(
+      broker,
+      DB_OBJECT_SERVICE_NAME,
+      data,
+    );
+  }
+
+  async updated(data) {
+    return registerRestrictionRules.register(
+      broker,
+      DB_OBJECT_SERVICE_NAME,
+      data,
+    );
+  }
+
+  async deleted(data) {
+    return registerRestrictionRules.remove(
+      broker,
+      DB_OBJECT_SERVICE_NAME,
+      data,
+    );
+  }
+}

package/src/handles/share_rules.ts

@@ -0,0 +1,28 @@
+import { registerShareRules, getObject } from "@steedos/objectql";
+import { BaseHandle } from "./base";
+import { DB_OBJECT_SERVICE_NAME } from "../constants";
+
+export class ShareRulesHandle extends BaseHandle {
+  constructor() {
+    super("share_rules");
+  }
+
+  async init() {
+    const dbRecords = await getObject("share_rules").directFind();
+    for (const dbRecord of dbRecords) {
+      await this.inserted(dbRecord);
+    }
+  }
+
+  async inserted(data) {
+    return registerShareRules.register(broker, DB_OBJECT_SERVICE_NAME, data);
+  }
+
+  async updated(data) {
+    return registerShareRules.register(broker, DB_OBJECT_SERVICE_NAME, data);
+  }
+
+  async deleted(data) {
+    return registerShareRules.remove(broker, DB_OBJECT_SERVICE_NAME, data);
+  }
+}

package/src/handles/tabs.ts

@@ -0,0 +1,28 @@
+import { addTabConfig, getObject, removeTab } from "@steedos/objectql";
+import { BaseHandle } from "./base";
+import { DB_OBJECT_SERVICE_NAME } from "../constants";
+
+export class TabsHandle extends BaseHandle {
+  constructor() {
+    super("tabs");
+  }
+
+  async init() {
+    const dbTabs = await getObject("tabs").directFind();
+    for (const dbTab of dbTabs) {
+      await this.inserted(dbTab);
+    }
+  }
+
+  async inserted(data) {
+    return addTabConfig(data, DB_OBJECT_SERVICE_NAME);
+  }
+
+  async updated(data) {
+    return addTabConfig(data, DB_OBJECT_SERVICE_NAME);
+  }
+
+  async deleted(data) {
+    return removeTab(data.name);
+  }
+}

package/src/handles/triggers.ts

@@ -0,0 +1,111 @@
+import { getObject } from "@steedos/objectql";
+import { BaseHandle } from "./base";
+import { DB_OBJECT_SERVICE_NAME } from "../constants";
+import * as _ from "lodash";
+
+export class TriggersHandle extends BaseHandle {
+  constructor() {
+    super("object_triggers");
+  }
+
+  async init() {
+    const dbTriggers = await getObject("object_triggers").directFind();
+    for (const dbTrigger of dbTriggers) {
+      await this.inserted(dbTrigger);
+    }
+  }
+
+  async inserted(trigger) {
+    if (this.isPatternTrigger(trigger)) {
+      trigger.isPattern = true;
+    }
+    await broker.call(
+      `object_triggers.add`,
+      { apiName: `${trigger.listenTo}.${trigger.name}`, data: trigger },
+      {
+        meta: {
+          metadataServiceName: DB_OBJECT_SERVICE_NAME,
+          caller: {
+            nodeID: broker.nodeID,
+            service: {
+              name: DB_OBJECT_SERVICE_NAME,
+            },
+          },
+        },
+      },
+    );
+    broker.broadcast("metadata.object_triggers.change", {
+      apiName: `${trigger.listenTo}.${trigger.name}`,
+      listenTo: trigger.listenTo,
+    });
+  }
+
+  async updated(trigger) {
+    if (this.isPatternTrigger(trigger)) {
+      trigger.isPattern = true;
+    }
+    await broker.call(
+      `object_triggers.add`,
+      { apiName: `${trigger.listenTo}.${trigger.name}`, data: trigger },
+      {
+        meta: {
+          metadataServiceName: DB_OBJECT_SERVICE_NAME,
+          caller: {
+            nodeID: broker.nodeID,
+            service: {
+              name: DB_OBJECT_SERVICE_NAME,
+            },
+          },
+        },
+      },
+    );
+    broker.broadcast("metadata.object_triggers.change", {
+      apiName: `${trigger.listenTo}.${trigger.name}`,
+      listenTo: trigger.listenTo,
+    });
+  }
+
+  async deleted(trigger) {
+    await broker.call(
+      `object_triggers.delete`,
+      { apiName: `${trigger.listenTo}.${trigger.name}` },
+      {
+        meta: {
+          metadataServiceName: DB_OBJECT_SERVICE_NAME,
+          caller: {
+            nodeID: broker.nodeID,
+            service: {
+              name: DB_OBJECT_SERVICE_NAME,
+            },
+          },
+        },
+      },
+    );
+    broker.broadcast("metadata.object_triggers.change", {
+      apiName: `${trigger.listenTo}.${trigger.name}`,
+      listenTo: trigger.listenTo,
+    });
+  }
+
+  private isPatternTrigger(data) {
+    const { listenTo } = data;
+    if (listenTo === "*") {
+      return true;
+    } else if (_.isArray(listenTo)) {
+      return true;
+    } else if (_.isRegExp(listenTo)) {
+      return true;
+    } else if (_.isString(listenTo) && listenTo.startsWith("/")) {
+      try {
+        if (_.isRegExp(eval(listenTo))) {
+          return true;
+        }
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      } catch (error) {
+        return false;
+      }
+      return false;
+    }
+    return false;
+  }
+}

package/src/index.ts

@@ -0,0 +1,120 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/*
+ * @Author: sunhaolin@hotoa.com
+ * @Date: 2022-03-04 17:02:52
+ * @LastEditors: baozhoutao@steedos.com
+ * @LastEditTime: 2025-03-12 15:11:33
+ * @Description:
+ */
+"use strict";
+// import * as actions from './actions';
+// import * as methods from './methods';
+import {
+  ObjectsHandle,
+  AppsHandle,
+  TabsHandle,
+  TriggersHandle,
+  ShareRulesHandle,
+} from "./handles";
+import { RestrictionRulesHandle } from "./handles/restriction_rules";
+
+const project = require("../package.json");
+const packageName = project.name;
+
+module.exports = {
+  name: packageName,
+  namespace: "steedos",
+  mixins: [],
+
+  /**
+   * Dependencies
+   */
+  dependencies: ["@steedos/service-core-objects"],
+
+  /**
+   * Actions
+   */
+  actions: {
+    // ...actions
+  },
+
+  /**
+   * Events
+   */
+  events: {
+    "$metadata.*": function (payload, sender, event, ctx) {
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      const self = this;
+      // console.log(`Event '${event}' received from ${sender} node:`, payload);
+      const { type, action, data } = payload;
+      switch (type) {
+        case "apps":
+          self.appsHandle.handleAction(action, data);
+          break;
+        case "tabs":
+          self.tabsHandle.handleAction(action, data);
+          break;
+        case "object_listviews":
+          self.objectsHandle.handleAction(action, { name: data.object_name });
+          break;
+        case "object_fields":
+          self.objectsHandle.handleAction(action, { name: data.object });
+          break;
+        case "object_actions":
+          self.objectsHandle.handleAction(action, { name: data.object });
+          break;
+        case "objects":
+          self.objectsHandle.handleAction(action, data);
+          break;
+        case "object_triggers":
+          self.triggersHandle.handleAction(action, data);
+          break;
+        case "share_rules":
+          self.shareRulesHandle.handleAction(action, data);
+          break;
+        case "restriction_rules":
+          self.restrictionRulesHandle.handleAction(action, data);
+          break;
+        default:
+          break;
+      }
+    },
+  },
+
+  /**
+   * Methods
+   */
+  methods: {
+    // ...methods
+  },
+
+  /**
+   * Service created lifecycle event handler
+   */
+  async created() {
+    this.objectsHandle = new ObjectsHandle();
+    this.appsHandle = new AppsHandle();
+    this.tabsHandle = new TabsHandle();
+    this.triggersHandle = new TriggersHandle();
+    this.shareRulesHandle = new ShareRulesHandle();
+    this.restrictionRulesHandle = new RestrictionRulesHandle();
+  },
+
+  /**
+   * Service started lifecycle event handler
+   */
+  async started() {
+    console.log(`Service ${packageName} started`);
+    await this.appsHandle.init();
+    await this.tabs;
+    await this.objectsHandle.init();
+    await this.triggersHandle.init();
+    await this.shareRulesHandle.init();
+    await this.restrictionRulesHandle.init();
+  },
+
+  /**
+   * Service stopped lifecycle event handler
+   */
+  async stopped() {},
+};

package/tsconfig.json

@@ -0,0 +1,34 @@
+{   
+    "compilerOptions": {
+        "outDir": "./lib",
+        "target": "es6",
+        "module": "commonjs",
+        "moduleResolution": "node",
+        "importHelpers": true,
+        "emitDecoratorMetadata": true,
+        "experimentalDecorators": true,
+        "sourceMap": true,
+        "noImplicitAny": false,
+        "declaration": true,
+        "noFallthroughCasesInSwitch": true,
+        //"noImplicitReturns": true,
+        "stripInternal": true,
+        "pretty": true,
+        "strictNullChecks": false,
+        "noUnusedLocals": true,
+        "downlevelIteration": true,
+        "skipLibCheck": true,
+        "lib": [
+          "es5",
+          "es6",
+          "es2015",
+          "es2016",
+          "es2017",
+          "esnext"
+        ],
+        "removeComments": true
+    },
+    "include": [
+      "./src/**/*"
+    ]
+  }