@tachybase/module-ui-schema 0.23.8

package/dist/server/server-hooks/hooks/bind-menu-to-role.d.ts

@@ -0,0 +1,5 @@
+export declare function bindMenuToRole({ schemaInstance, db, options }: {
+    schemaInstance: any;
+    db: any;
+    options: any;
+}): Promise<void>;

package/dist/server/server-hooks/hooks/bind-menu-to-role.js

@@ -0,0 +1,40 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var bind_menu_to_role_exports = {};
+__export(bind_menu_to_role_exports, {
+  bindMenuToRole: () => bindMenuToRole
+});
+module.exports = __toCommonJS(bind_menu_to_role_exports);
+async function bindMenuToRole({ schemaInstance, db, options }) {
+  const { transaction } = options;
+  const addNewMenuRoles = await db.getRepository("roles").find({
+    filter: {
+      allowNewMenu: true
+    }
+  });
+  for (const role of addNewMenuRoles) {
+    await db.getRepository("roles.menuUiSchemas", role.get("name")).add({
+      tk: schemaInstance.get("x-uid"),
+      transaction
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  bindMenuToRole
+});

package/dist/server/server-hooks/hooks/factory.d.ts

@@ -0,0 +1,6 @@
+import { HookType } from '../index';
+export declare function hookFactory(hookType: HookType, hookName: string, hookFunc: any): {
+    hookType: HookType;
+    hookName: string;
+    hookFunc: any;
+};

package/dist/server/server-hooks/hooks/factory.js

@@ -0,0 +1,33 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var factory_exports = {};
+__export(factory_exports, {
+  hookFactory: () => hookFactory
+});
+module.exports = __toCommonJS(factory_exports);
+function hookFactory(hookType, hookName, hookFunc) {
+  return {
+    hookType,
+    hookName,
+    hookFunc
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hookFactory
+});

package/dist/server/server-hooks/hooks/index.d.ts

@@ -0,0 +1,6 @@
+declare const hooks: {
+    hookType: import("..").HookType;
+    hookName: string;
+    hookFunc: any;
+}[];
+export { hooks };

package/dist/server/server-hooks/hooks/index.js

@@ -0,0 +1,36 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var hooks_exports = {};
+__export(hooks_exports, {
+  hooks: () => hooks
+});
+module.exports = __toCommonJS(hooks_exports);
+var import_bind_menu_to_role = require("./bind-menu-to-role");
+var import_factory = require("./factory");
+var import_remove_parents_if_no_children = require("./remove-parents-if-no-children");
+var import_remove_schema = require("./remove-schema");
+const hooks = [
+  (0, import_factory.hookFactory)("onCollectionDestroy", "removeSchema", import_remove_schema.removeSchema),
+  (0, import_factory.hookFactory)("onCollectionFieldDestroy", "removeSchema", import_remove_schema.removeSchema),
+  (0, import_factory.hookFactory)("onSelfCreate", "bindMenuToRole", import_bind_menu_to_role.bindMenuToRole),
+  (0, import_factory.hookFactory)("onSelfMove", "removeParentsIfNoChildren", import_remove_parents_if_no_children.removeParentsIfNoChildren)
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  hooks
+});

package/dist/server/server-hooks/hooks/remove-parents-if-no-children.d.ts

@@ -0,0 +1,6 @@
+export declare function removeParentsIfNoChildren({ schemaInstance, db, options, params }: {
+    schemaInstance: any;
+    db: any;
+    options: any;
+    params: any;
+}): Promise<void>;

package/dist/server/server-hooks/hooks/remove-parents-if-no-children.js

@@ -0,0 +1,35 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var remove_parents_if_no_children_exports = {};
+__export(remove_parents_if_no_children_exports, {
+  removeParentsIfNoChildren: () => removeParentsIfNoChildren
+});
+module.exports = __toCommonJS(remove_parents_if_no_children_exports);
+async function removeParentsIfNoChildren({ schemaInstance, db, options, params }) {
+  const { transaction, oldParentUid } = options;
+  const uiSchemaRepository = db.getRepository("uiSchemas");
+  await uiSchemaRepository.recursivelyRemoveIfNoChildren({
+    transaction,
+    uid: oldParentUid,
+    breakRemoveOn: params == null ? void 0 : params.breakRemoveOn
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  removeParentsIfNoChildren
+});

package/dist/server/server-hooks/hooks/remove-schema.d.ts

@@ -0,0 +1,6 @@
+export declare function removeSchema({ schemaInstance, options, db, params }: {
+    schemaInstance: any;
+    options: any;
+    db: any;
+    params: any;
+}): Promise<void>;

package/dist/server/server-hooks/hooks/remove-schema.js

@@ -0,0 +1,42 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var remove_schema_exports = {};
+__export(remove_schema_exports, {
+  removeSchema: () => removeSchema
+});
+module.exports = __toCommonJS(remove_schema_exports);
+async function removeSchema({ schemaInstance, options, db, params }) {
+  const { transaction } = options;
+  const uiSchemaRepository = db.getRepository("uiSchemas");
+  const uid = schemaInstance.get("x-uid");
+  if (params == null ? void 0 : params.removeParentsIfNoChildren) {
+    await uiSchemaRepository.removeEmptyParents({
+      uid,
+      breakRemoveOn: params["breakRemoveOn"],
+      transaction
+    });
+  } else {
+    await uiSchemaRepository.remove(uid, {
+      transaction
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  removeSchema
+});

package/dist/server/server-hooks/index.d.ts

@@ -0,0 +1,25 @@
+import { Database } from '@tachybase/database';
+export type HookType = 'onSelfDestroy' | 'onCollectionDestroy' | 'onCollectionFieldDestroy' | 'onAnyCollectionFieldDestroy' | 'onSelfCreate' | 'onSelfSave' | 'onSelfMove';
+export declare class ServerHooks {
+    protected db: Database;
+    hooks: Map<HookType, Map<string, any>>;
+    constructor(db: Database);
+    registerHooks(): void;
+    listen(): void;
+    protected callSchemaInstanceHooksByType(schemaInstance: any, options: any, type: HookType): Promise<void>;
+    protected onUiSchemaMove(schemaInstance: any, options: any): Promise<void>;
+    protected onCollectionDestroy(collectionModel: any, options: any): Promise<void>;
+    protected onAnyCollectionFieldDestroy(fieldModel: any, options: any): Promise<void>;
+    protected onCollectionFieldDestroy(fieldModel: any, options: any): Promise<void>;
+    protected onUiSchemaCreate(schemaInstance: any, options: any): Promise<void>;
+    protected onUiSchemaSave(schemaInstance: any, options: any): Promise<void>;
+    protected findHooksAndCall(hooksFilter: any, hooksArgs: any, transaction: any): Promise<void>;
+    /**
+     * register a server hook function
+     * @param type type of server hook
+     * @param name name of server hook
+     * @param hookFunc server hook function
+     */
+    register(type: HookType, name: string, hookFunc: any): void;
+    remove(type: HookType, name: string): void;
+}

package/dist/server/server-hooks/index.js

@@ -0,0 +1,165 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_hooks_exports = {};
+__export(server_hooks_exports, {
+  ServerHooks: () => ServerHooks
+});
+module.exports = __toCommonJS(server_hooks_exports);
+var import_hooks = require("./hooks");
+class ServerHooks {
+  constructor(db) {
+    this.db = db;
+    this.listen();
+    this.registerHooks();
+  }
+  hooks = /* @__PURE__ */ new Map();
+  registerHooks() {
+    import_hooks.hooks.forEach((hook) => this.register(hook.hookType, hook.hookName, hook.hookFunc));
+  }
+  listen() {
+    this.db.on("fields.afterDestroy", async (model, options) => {
+      await this.onCollectionFieldDestroy(model, options);
+      await this.onAnyCollectionFieldDestroy(model, options);
+    });
+    this.db.on("collections.afterDestroy", async (model, options) => {
+      await this.onCollectionDestroy(model, options);
+    });
+    this.db.on("uiSchemas.afterCreateWithAssociations", async (model, options) => {
+      await this.onUiSchemaCreate(model, options);
+    });
+    this.db.on("uiSchemaMove", async (model, options) => {
+      await this.onUiSchemaMove(model, options);
+    });
+    this.db.on("uiSchemas.afterSave", async (model, options) => {
+      await this.onUiSchemaSave(model, options);
+    });
+  }
+  async callSchemaInstanceHooksByType(schemaInstance, options, type) {
+    var _a;
+    const { transaction } = options;
+    const hooks2 = schemaInstance.getServerHooksByType(type);
+    for (const hook of hooks2) {
+      const hookFunc = (_a = this.hooks.get(type)) == null ? void 0 : _a.get(hook["method"]);
+      await (hookFunc == null ? void 0 : hookFunc({
+        schemaInstance,
+        options,
+        db: this.db,
+        params: hook["params"]
+      }));
+    }
+  }
+  async onUiSchemaMove(schemaInstance, options) {
+    await this.callSchemaInstanceHooksByType(schemaInstance, options, "onSelfMove");
+  }
+  async onCollectionDestroy(collectionModel, options) {
+    const { transaction } = options;
+    await this.findHooksAndCall(
+      {
+        type: "onCollectionDestroy",
+        collection: collectionModel.get("name")
+      },
+      {
+        collectionInstance: collectionModel,
+        options
+      },
+      transaction
+    );
+  }
+  async onAnyCollectionFieldDestroy(fieldModel, options) {
+    const { transaction } = options;
+    const collectionName = fieldModel.get("collectionName");
+    await this.findHooksAndCall(
+      {
+        type: "onAnyCollectionFieldDestroy",
+        collection: collectionName
+      },
+      {
+        collectionFieldInstance: fieldModel,
+        options
+      },
+      transaction
+    );
+  }
+  async onCollectionFieldDestroy(fieldModel, options) {
+    const { transaction } = options;
+    const collectionName = fieldModel.get("collectionName");
+    const fieldName = fieldModel.get("name");
+    await this.findHooksAndCall(
+      {
+        type: "onCollectionFieldDestroy",
+        collection: collectionName,
+        field: fieldName
+      },
+      {
+        collectionFieldInstance: fieldModel,
+        options
+      },
+      transaction
+    );
+  }
+  async onUiSchemaCreate(schemaInstance, options) {
+    await this.callSchemaInstanceHooksByType(schemaInstance, options, "onSelfCreate");
+  }
+  async onUiSchemaSave(schemaInstance, options) {
+    await this.callSchemaInstanceHooksByType(schemaInstance, options, "onSelfSave");
+  }
+  async findHooksAndCall(hooksFilter, hooksArgs, transaction) {
+    var _a;
+    const hooks2 = await this.db.getRepository("uiSchemaServerHooks").find({
+      filter: hooksFilter,
+      appends: ["uiSchema"],
+      transaction
+    });
+    for (const hookRecord of hooks2) {
+      const hoodMethodName = hookRecord.get("method");
+      const hookFunc = (_a = this.hooks.get(hookRecord.get("type"))) == null ? void 0 : _a.get(hoodMethodName);
+      if (hookFunc) {
+        await hookFunc({
+          ...hooksArgs,
+          schemaInstance: hookRecord.uiSchema,
+          db: this.db,
+          params: hookRecord.get("params")
+        });
+      }
+    }
+  }
+  /**
+   * register a server hook function
+   * @param type type of server hook
+   * @param name name of server hook
+   * @param hookFunc server hook function
+   */
+  register(type, name, hookFunc) {
+    if (!this.hooks.has(type)) {
+      this.hooks.set(type, /* @__PURE__ */ new Map());
+    }
+    const hookTypeMap = this.hooks.get(type);
+    hookTypeMap.set(name, hookFunc);
+  }
+  remove(type, name) {
+    if (!this.hooks.has(type)) {
+      return;
+    }
+    const hookTypeMap = this.hooks.get(type);
+    hookTypeMap.delete(name);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServerHooks
+});

package/dist/server/server-hooks/model.d.ts

@@ -0,0 +1,3 @@
+import { Model } from '@tachybase/database';
+export declare class ServerHookModel extends Model {
+}

package/dist/server/server-hooks/model.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var model_exports = {};
+__export(model_exports, {
+  ServerHookModel: () => ServerHookModel
+});
+module.exports = __toCommonJS(model_exports);
+var import_database = require("@tachybase/database");
+class ServerHookModel extends import_database.Model {
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ServerHookModel
+});

package/dist/server/server.d.ts

@@ -0,0 +1,8 @@
+import { Plugin } from '@tachybase/server';
+import { ServerHooks } from './server-hooks';
+export declare class ModuleUiSchema extends Plugin {
+    serverHooks: ServerHooks;
+    registerRepository(): void;
+    beforeLoad(): Promise<void>;
+}
+export default ModuleUiSchema;

package/dist/server/server.js

@@ -0,0 +1,136 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  ModuleUiSchema: () => ModuleUiSchema,
+  default: () => server_default
+});
+module.exports = __toCommonJS(server_exports);
+var import_database = require("@tachybase/database");
+var import_server = require("@tachybase/server");
+var import_utils = require("@tachybase/utils");
+var import_ui_schema_action = require("./actions/ui-schema-action");
+var import_model = require("./model");
+var import_repository = __toESM(require("./repository"));
+var import_server_hooks = require("./server-hooks");
+var import_model2 = require("./server-hooks/model");
+class ModuleUiSchema extends import_server.Plugin {
+  serverHooks;
+  registerRepository() {
+    this.app.db.registerRepositories({
+      UiSchemaRepository: import_repository.default
+    });
+  }
+  async beforeLoad() {
+    const db = this.app.db;
+    this.serverHooks = new import_server_hooks.ServerHooks(db);
+    this.app.db.registerModels({ MagicAttributeModel: import_database.MagicAttributeModel, UiSchemaModel: import_model.UiSchemaModel, ServerHookModel: import_model2.ServerHookModel });
+    this.registerRepository();
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}.block-templates`,
+      actions: ["uiSchemaTemplates:*"]
+    });
+    this.app.acl.registerSnippet({
+      name: "ui.uiSchemas",
+      actions: [
+        "uiSchemas:insert",
+        "uiSchemas:insertNewSchema",
+        "uiSchemas:remove",
+        "uiSchemas:patch",
+        "uiSchemas:batchPatch",
+        "uiSchemas:clearAncestor",
+        "uiSchemas:insertBeforeBegin",
+        "uiSchemas:insertAfterBegin",
+        "uiSchemas:insertBeforeEnd",
+        "uiSchemas:insertAfterEnd",
+        "uiSchemas:insertAdjacent",
+        "uiSchemas:saveAsTemplate"
+      ]
+    });
+    db.on("uiSchemas.beforeCreate", function setUid(model) {
+      if (!model.get("name")) {
+        model.set("name", (0, import_utils.uid)());
+      }
+    });
+    db.on("uiSchemas.afterCreate", async function insertSchema(model, options) {
+      const { transaction } = options;
+      const uiSchemaRepository = db.getCollection("uiSchemas").repository;
+      const context = options.context;
+      if (context == null ? void 0 : context.disableInsertHook) {
+        return;
+      }
+      await uiSchemaRepository.insert(model.toJSON(), {
+        transaction
+      });
+    });
+    db.on("uiSchemas.afterUpdate", async function patchSchema(model, options) {
+      const { transaction } = options;
+      const uiSchemaRepository = db.getCollection("uiSchemas").repository;
+      await uiSchemaRepository.patch(model.toJSON(), {
+        transaction
+      });
+    });
+    this.app.resourcer.use(
+      async (ctx, next) => {
+        var _a;
+        const { resourceName, actionName } = ctx.action.params;
+        if (resourceName === "uiSchemas" && actionName === "remove") {
+          const skip = await ctx.app.acl.allowManager.isAllowed(resourceName, actionName, ctx);
+          if (skip) {
+            return next();
+          }
+          const role = (_a = ctx == null ? void 0 : ctx.state) == null ? void 0 : _a.currentRole;
+          if (!role) {
+            ctx.throw(403, "No Permission: Role not found");
+          }
+          const aclRole = ctx.app.acl.roles.get(role);
+          if (!aclRole) {
+            ctx.throw(403, "No Permission: Role not found");
+          }
+          const snippetAllowed = aclRole.snippetAllowed(`${resourceName}:${actionName}`);
+          if (!snippetAllowed) {
+            ctx.throw(403, "No Permission: Role lacks remove permission for uiSchemas");
+          }
+        }
+        await next();
+      },
+      { tag: "intercept-ui-schema-remove", after: "acl" }
+    );
+    this.app.resourcer.define({
+      name: "uiSchemas",
+      actions: import_ui_schema_action.uiSchemaActions
+    });
+    this.app.acl.allow("uiSchemas", ["getProperties", "getJsonSchema"], "loggedIn");
+    this.app.acl.allow("uiSchemaTemplates", ["get", "list"], "public");
+  }
+}
+var server_default = ModuleUiSchema;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ModuleUiSchema
+});