@tachybase/module-collection 0.23.8

package/dist/server/resourcers/views.js

@@ -0,0 +1,98 @@
+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 views_exports = {};
+__export(views_exports, {
+  default: () => views_default
+});
+module.exports = __toCommonJS(views_exports);
+var import_database = require("@tachybase/database");
+var views_default = {
+  name: "dbViews",
+  actions: {
+    async get(ctx, next) {
+      const { filterByTk, schema } = ctx.action.params;
+      const db = ctx.app.db;
+      const fields = await import_database.ViewFieldInference.inferFields({
+        db,
+        viewName: filterByTk,
+        viewSchema: schema
+      });
+      ctx.body = {
+        fields,
+        sources: [
+          ...new Set(
+            Object.values(fields).map((field) => field.source).filter(Boolean).map((source) => source.split(".")[0])
+          )
+        ]
+      };
+      await next();
+    },
+    list: async function(ctx, next) {
+      const db = ctx.app.db;
+      const dbViews = await db.queryInterface.listViews();
+      const viewCollections = Array.from(db.collections.values()).filter((collection) => collection.isView());
+      ctx.body = dbViews.map((dbView) => {
+        return {
+          ...dbView
+        };
+      }).filter((dbView) => {
+        return !viewCollections.find((collection) => {
+          const viewName = dbView.name;
+          const schema = dbView.schema;
+          const collectionViewName = collection.options.viewName || collection.options.name;
+          return collectionViewName === viewName && collection.options.schema === schema;
+        });
+      });
+      await next();
+    },
+    async query(ctx, next) {
+      const { filterByTk, fieldTypes, schema = "public", page = 1, pageSize = 10 } = ctx.action.params;
+      const offset = (page - 1) * pageSize;
+      const limit = 1 * pageSize;
+      const sql = `SELECT *
+                   FROM ${ctx.app.db.utils.quoteTable(
+        ctx.app.db.utils.addSchema(filterByTk, schema)
+      )} LIMIT ${limit} OFFSET ${offset}`;
+      const rawValues = await ctx.app.db.sequelize.query(sql, { type: "SELECT" });
+      if (fieldTypes) {
+        for (const raw of rawValues) {
+          const fakeInstance = {
+            dataValues: raw,
+            getDataValue: (key) => raw[key]
+          };
+          for (const fieldName of Object.keys(fieldTypes)) {
+            const fieldType = fieldTypes[fieldName];
+            const FieldClass = ctx.app.db.fieldTypes.get(fieldType);
+            const fieldOptions = new FieldClass(
+              { name: fieldName },
+              {
+                db: ctx.app.db
+              }
+            ).options;
+            if (fieldOptions.get) {
+              const newValue = fieldOptions.get.apply(fakeInstance);
+              raw[fieldName] = newValue;
+            }
+          }
+        }
+      }
+      ctx.body = rawValues;
+      await next();
+    }
+  }
+};

package/dist/server/server.d.ts

@@ -0,0 +1,11 @@
+import { Filter } from '@tachybase/database';
+import { Plugin } from '@tachybase/server';
+export declare class CollectionManagerPlugin extends Plugin {
+    schema: string;
+    private loadFilter;
+    setLoadFilter(filter: Filter): void;
+    beforeLoad(): Promise<void>;
+    load(): Promise<void>;
+    install(): Promise<void>;
+}
+export default CollectionManagerPlugin;

package/dist/server/server.js

@@ -0,0 +1,332 @@
+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, {
+  CollectionManagerPlugin: () => CollectionManagerPlugin,
+  default: () => server_default
+});
+module.exports = __toCommonJS(server_exports);
+var import_path = __toESM(require("path"));
+var process = __toESM(require("process"));
+var import_worker_threads = require("worker_threads");
+var import_database = require("@tachybase/database");
+var import_server = require("@tachybase/server");
+var import_async_mutex = require("async-mutex");
+var import_lodash = __toESM(require("lodash"));
+var import__ = require(".");
+var import_collectionImportExportMeta = require("./actions/collectionImportExportMeta");
+var import_hooks = require("./hooks");
+var import_beforeCreateForValidateField = require("./hooks/beforeCreateForValidateField");
+var import_beforeCreateForViewCollection = require("./hooks/beforeCreateForViewCollection");
+var import_models = require("./models");
+var import_collections = __toESM(require("./resourcers/collections"));
+var import_sql = __toESM(require("./resourcers/sql"));
+var import_views = __toESM(require("./resourcers/views"));
+class CollectionManagerPlugin extends import_server.Plugin {
+  schema;
+  loadFilter = {};
+  setLoadFilter(filter) {
+    this.loadFilter = filter;
+  }
+  async beforeLoad() {
+    if (this.app.db.inDialect("postgres")) {
+      this.schema = process.env.COLLECTION_MANAGER_SCHEMA || this.db.options.schema || "public";
+    }
+    this.app.db.registerRepositories({
+      CollectionRepository: import__.CollectionRepository
+    });
+    this.app.db.registerModels({
+      CollectionModel: import_models.CollectionModel,
+      FieldModel: import_models.FieldModel
+    });
+    this.db.addMigrations({
+      namespace: "collection-manager",
+      directory: import_path.default.resolve(__dirname, "./migrations"),
+      context: {
+        plugin: this
+      }
+    });
+    this.app.db.on("collections.beforeCreate", async (model) => {
+      if (this.app.db.inDialect("postgres") && this.schema && model.get("from") !== "db2cm" && !model.get("schema")) {
+        model.set("schema", this.schema);
+      }
+    });
+    this.app.db.on("collections.beforeCreate", (0, import_beforeCreateForViewCollection.beforeCreateForViewCollection)(this.db));
+    this.app.db.on(
+      "collections.afterCreateWithAssociations",
+      async (model, { context, transaction }) => {
+        if (context) {
+          await model.migrate({
+            transaction
+          });
+        }
+      }
+    );
+    this.app.db.on("collections.beforeDestroy", async (model, options) => {
+      const removeOptions = {};
+      if (options.transaction) {
+        removeOptions["transaction"] = options.transaction;
+      }
+      const cascade = import_lodash.default.get(options, "context.action.params.cascade", false);
+      if (cascade === true || cascade === "true") {
+        removeOptions["cascade"] = true;
+      }
+      await model.remove(removeOptions);
+    });
+    this.app.db.on("fields.beforeCreate", (0, import_hooks.beforeCreateForReverseField)(this.app.db));
+    this.app.db.on("fields.beforeCreate", async (model, options) => {
+      const collectionName = model.get("collectionName");
+      const collection = this.app.db.getCollection(collectionName);
+      if (!collection) {
+        return;
+      }
+      if (collection.isInherited() && collection.parentFields().has(model.get("name"))) {
+        model.set("overriding", true);
+      }
+    });
+    this.app.db.on("fields.beforeValidate", async (model) => {
+      if (model.get("name") && model.get("name").includes(".")) {
+        model.set("field", model.get("name"));
+        model.set("name", model.get("name").replace(/\./g, "_"));
+      }
+    });
+    this.app.db.on("fields.beforeCreate", async (model, options) => {
+      if (model.get("source")) return;
+      const type = model.get("type");
+      const fn = import_hooks.beforeInitOptions[type];
+      if (fn) {
+        await fn(model, { database: this.app.db });
+      }
+    });
+    this.app.db.on("fields.beforeCreate", (0, import_beforeCreateForValidateField.beforeCreateForValidateField)(this.app.db));
+    this.app.db.on("fields.afterCreate", (0, import_hooks.afterCreateForReverseField)(this.app.db));
+    this.app.db.on("fields.afterCreate", async (model, { context, transaction }) => {
+      if (context) {
+        await model.migrate({
+          isNew: true,
+          transaction
+        });
+      }
+    });
+    this.app.db.on("fields.afterCreate", (0, import_hooks.afterCreateForForeignKeyField)(this.app.db));
+    this.app.db.on("fields.beforeUpdate", async (model, options) => {
+      const newValue = options.values;
+      if (model.get("reverseKey") && import_lodash.default.get(newValue, "reverseField") && !import_lodash.default.get(newValue, "reverseField.key")) {
+        const field = await this.app.db.getModel("fields").findByPk(model.get("reverseKey"), { transaction: options.transaction });
+        if (field) {
+          throw new Error("cant update field without a reverseField key");
+        }
+      }
+      if (model.get("sortable") && model.get("type") === "hasMany") {
+        model.set("sortBy", model.get("foreignKey") + "Sort");
+      }
+    });
+    this.app.db.on("fields.afterUpdate", async (model, { context, transaction }) => {
+      const prevOptions = model.previous("options");
+      const currentOptions = model.get("options");
+      if (context) {
+        const prev = prevOptions["unique"];
+        const next = currentOptions["unique"];
+        if (Boolean(prev) !== Boolean(next)) {
+          await model.syncUniqueIndex({ transaction });
+        }
+      }
+      const prevDefaultValue = prevOptions["defaultValue"];
+      const currentDefaultValue = currentOptions["defaultValue"];
+      if (prevDefaultValue !== currentDefaultValue) {
+        await model.syncDefaultValue({ transaction, defaultValue: currentDefaultValue });
+      }
+      const prevOnDelete = prevOptions["onDelete"];
+      const currentOnDelete = currentOptions["onDelete"];
+      if (prevOnDelete !== currentOnDelete) {
+        await model.syncReferenceCheckOption({ transaction });
+      }
+      if (model.get("type") === "hasMany" && model.get("sortable") && model.get("sortBy")) {
+        await model.syncSortByField({ transaction });
+      }
+    });
+    this.app.db.on("fields.afterSaveWithAssociations", async (model, { context, transaction }) => {
+      if (context) {
+        await model.load({ transaction });
+      }
+    });
+    this.app.db.on("fields.beforeDestroy", (0, import_hooks.beforeDestroyForeignKey)(this.app.db));
+    const mutex = new import_async_mutex.Mutex();
+    this.app.db.on("fields.beforeDestroy", async (model, options) => {
+      await mutex.runExclusive(async () => {
+        await model.remove(options);
+      });
+    });
+    this.app.db.on("fields.afterDestroy", async (model, options) => {
+      const { transaction } = options;
+      const collectionName = model.get("collectionName");
+      const childCollections = this.db.inheritanceMap.getChildren(collectionName);
+      const childShouldRemoveField = Array.from(childCollections).filter((item) => {
+        const parents = Array.from(this.db.inheritanceMap.getParents(item)).map((parent) => {
+          const collection = this.db.getCollection(parent);
+          const field = collection.getField(model.get("name"));
+          return field;
+        }).filter(Boolean);
+        return parents.length === 0;
+      });
+      await this.db.getCollection("fields").repository.destroy({
+        filter: {
+          name: model.get("name"),
+          collectionName: {
+            $in: childShouldRemoveField
+          },
+          options: {
+            overriding: true
+          }
+        },
+        transaction
+      });
+    });
+    const loadCollections = async () => {
+      this.log.debug("loading custom collections", { method: "loadCollections" });
+      this.app.setMaintainingMessage("loading custom collections");
+      await this.app.db.getRepository("collections").load({
+        filter: this.loadFilter
+      });
+    };
+    this.app.on("beforeStart", loadCollections);
+    if (!import_worker_threads.isMainThread) {
+      return;
+    }
+    this.app.resourcer.use(
+      async (ctx, next) => {
+        const { resourceName, actionName } = ctx.action;
+        if (resourceName === "collections.fields" && actionName === "update") {
+          const { updateAssociationValues = [] } = ctx.action.params;
+          updateAssociationValues.push("uiSchema");
+          ctx.action.mergeParams({
+            updateAssociationValues
+          });
+        }
+        await next();
+      },
+      { tag: "appendUISchemaOnFieldUpdate" }
+    );
+    this.app.acl.allow("collections", "list", "loggedIn");
+    this.app.acl.allow("collectionCategories", "list", "loggedIn");
+    this.app.resourcer.define(import_collectionImportExportMeta.collectionImportExportMeta);
+  }
+  async load() {
+    await this.importCollections(import_path.default.resolve(__dirname, "./collections"));
+    this.db.getRepository("collections").setApp(this.app);
+    const errorHandlerPlugin = this.app.getPlugin("error-handler");
+    errorHandlerPlugin.errorHandler.register(
+      (err) => {
+        return err instanceof import_database.UniqueConstraintError;
+      },
+      (err, ctx) => {
+        return ctx.throw(400, ctx.t(`The value of ${Object.keys(err.fields)} field duplicated`));
+      }
+    );
+    this.app.resourcer.use(
+      async (ctx, next) => {
+        if (ctx.action.resourceName === "collections.fields" && ["create", "update"].includes(ctx.action.actionName)) {
+          ctx.action.mergeParams({
+            updateAssociationValues: ["reverseField"]
+          });
+        }
+        await next();
+      },
+      { tag: "setReverseFieldOnFieldChange" }
+    );
+    this.app.resource(import_views.default);
+    this.app.resource(import_sql.default);
+    this.app.actions(import_collections.default);
+    const handleFieldSource = (fields) => {
+      var _a;
+      for (const field of import_lodash.default.castArray(fields)) {
+        if (field.get("source")) {
+          const [collectionSource, fieldSource] = field.get("source").split(".");
+          const collectionField = (_a = this.app.db.getCollection(collectionSource)) == null ? void 0 : _a.getField(fieldSource);
+          if (!collectionField) {
+            continue;
+          }
+          const newOptions = {};
+          import_lodash.default.merge(newOptions, import_lodash.default.omit(collectionField.options, "name"));
+          import_lodash.default.mergeWith(newOptions, field.get(), (objValue, srcValue) => {
+            if (srcValue === null) {
+              return objValue;
+            }
+          });
+          field.set("options", newOptions);
+        }
+      }
+    };
+    this.app.resourcer.use(
+      async (ctx, next) => {
+        var _a, _b;
+        await next();
+        if (ctx.action.resourceName === "collections" && ctx.action.actionName === "list" && ((_a = ctx.action.params) == null ? void 0 : _a.paginate) === "false") {
+          for (const collection of ctx.body) {
+            if (collection.get("view")) {
+              const fields = collection.fields;
+              handleFieldSource(fields);
+            }
+          }
+        }
+        if (ctx.action.resourceName === "collections.fields" && ctx.action.actionName === "list") {
+          handleFieldSource(((_b = ctx.action.params) == null ? void 0 : _b.paginate) === "false" ? ctx.body : ctx.body.rows);
+        }
+        if (ctx.action.resourceName === "collections.fields" && ctx.action.actionName === "get") {
+          handleFieldSource(ctx.body);
+        }
+      },
+      { tag: "handleFieldSourceOnListAndGet" }
+    );
+    this.app.db.extendCollection({
+      name: "collectionCategory",
+      dumpRules: "required",
+      origin: this.options.packageName
+    });
+  }
+  async install() {
+    const dataSourcesCollection = this.app.db.getCollection("dataSources");
+    if (dataSourcesCollection) {
+      await dataSourcesCollection.repository.firstOrCreate({
+        filterKeys: ["key"],
+        values: {
+          key: "main",
+          type: "main",
+          displayName: '{{t("Main")}}',
+          fixed: true,
+          options: {}
+        }
+      });
+    }
+  }
+}
+var server_default = CollectionManagerPlugin;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CollectionManagerPlugin
+});